// TODO: Refactor into multiple functions
@Override
public Entity buildEntity() {
Entity player = new Entity();
// Define the body
BodyDef playerBody = new BodyDef();
playerBody.type = BodyDef.BodyType.DynamicBody;
playerBody.position.set(0, 0);
// Create the components
PhysicsComponent p = new PhysicsComponent(physicsWorld.createBody(playerBody), player);
RenderComponent r = new RenderComponent();
KeyboardInputComponent i = new KeyboardInputComponent();
MoveAction m = new MoveAction();
// Properties for the components
Polygon sprite =
new Polygon(
new float[] {
0, 5,
3, -3,
0, -2,
-3, -3
});
PolygonShape fixShape = new PolygonShape();
fixShape.set(sprite.getVertices());
FixtureDef def = new FixtureDef();
def.shape = fixShape;
def.density = 1.2f;
def.friction = 0f;
def.restitution = 0.1f;
// Apply properties
p.physicsBody.createFixture(def);
r.renderColor = Color.BLUE;
r.sprite = sprite;
m.lin_v = 5f;
m.rot_v = 2f;
// Add to player
player.add(p);
player.add(r);
player.add(i);
player.add(m);
return player;
}
public float[] getMeshVertices(Polygon poly) {
// Top
verticesMesh[0] = poly.getTransformedVertices()[0]; // go left X
verticesMesh[1] = poly.getTransformedVertices()[1]; // go up Y
// Right
verticesMesh[4] = poly.getTransformedVertices()[2]; // go right X
verticesMesh[5] = poly.getTransformedVertices()[3]; // go up Y
// Bottom Right
verticesMesh[8] = poly.getTransformedVertices()[4]; // go right X
verticesMesh[9] = poly.getTransformedVertices()[5]; // go down Y
return verticesMesh;
}
/**
* Clamp the point to the nearest polygon segment
*
* @param poly The polygon
* @param x The original point X
* @param y The original point Y
* @param dest The clamped point
* @return The segment where the clamped point belongs
*/
public static int getClampedPoint(Polygon poly, float x, float y, Vector2 dest) {
float verts[] = poly.getTransformedVertices();
float dTmp;
Intersector.nearestSegmentPoint(verts[0], verts[1], verts[2], verts[3], x, y, dest);
int nearest = 0;
float d = Vector2.dst(x, y, dest.x, dest.y);
for (int i = 2; i < verts.length; i += 2) {
Intersector.nearestSegmentPoint(
verts[i],
verts[i + 1],
verts[(i + 2) % verts.length],
verts[(i + 3) % verts.length],
x,
y,
tmp);
dTmp = Vector2.dst(x, y, tmp.x, tmp.y);
if (dTmp < d) {
d = dTmp;
nearest = i;
dest.set(tmp);
}
}
return nearest;
}
public static void deletePoint(Polygon poly, int index) {
float verts[] = poly.getVertices();
if (verts.length < 8) return;
int length = verts.length;
float destination[] = new float[length - 2];
// index = index * 2;
System.arraycopy(verts, 0, destination, 0, index);
System.arraycopy(verts, index + 2, destination, index, length - index - 2);
poly.setVertices(destination);
}
public static void addPoint(Polygon poly, float x, float y, int index) {
float verts[] = poly.getVertices();
x -= poly.getX();
y -= poly.getY();
int length = verts.length;
float destination[] = new float[length + 2];
System.arraycopy(verts, 0, destination, 0, index);
destination[index] = x;
destination[index + 1] = y;
System.arraycopy(verts, index, destination, index + 2, length - index);
poly.setVertices(destination);
}
public static boolean inLineOfSight(Vector2 p1, Vector2 p2, Polygon polygon, boolean obstacle) {
tmp.set(p1);
tmp2.set(p2);
float verts[] = polygon.getTransformedVertices();
for (int i = 0; i < verts.length; i += 2) {
if (lineSegmentsCross(
tmp.x,
tmp.y,
tmp2.x,
tmp2.y,
verts[i],
verts[i + 1],
verts[(i + 2) % verts.length],
verts[(i + 3) % verts.length])) return false;
}
tmp.add(tmp2);
tmp.x /= 2;
tmp.y /= 2;
boolean result = PolygonUtils.isPointInside(polygon, tmp.x, tmp.y, !obstacle);
return obstacle ? !result : result;
}
public TouchableEntity getTouchableEntity(AgentEntity agentEntity) {
TouchableEntity touchableEntity = new TouchableEntity();
DamageEffect damageEffect = new DamageEffect();
damageEffect.setDamage(damage);
damageEffect.setOriginatingAgent(agentEntity);
touchableEntity.setCollisionPolygon(new Polygon(attackPolygon.getVertices()));
Vector2 attackPosition = new Vector2();
if (agentEntity.isFacingLeft()) {
attackPosition
.add(agentEntity.getLeftBoundingSide())
.sub(attackPolygon.getBoundingRectangle().width, 0);
} else {
attackPosition.add(agentEntity.getRightBoundingSide());
}
touchableEntity.setPosition(attackPosition);
return touchableEntity;
}
public static boolean deletePoint(Polygon poly, float x, float y, float tolerance) {
float verts[] = poly.getTransformedVertices();
for (int i = 0; i < verts.length; i += 2) {
if (Vector2.dst(x, y, verts[i], verts[i + 1]) < tolerance) {
deletePoint(poly, i);
return true;
}
}
return false;
}
public void drawBBoxLines(ShapeRenderer renderer) {
// renderer.begin(ShapeType.Rectangle);
renderer.begin(ShapeType.Line);
for (BaseActor a : actors.values()) {
Polygon p = a.getBBox();
if (p == null) {
EngineLogger.error("ERROR DRAWING BBOX FOR: " + a.getId());
}
if (a instanceof ObstacleActor) renderer.setColor(OBSTACLE_COLOR);
else renderer.setColor(ACTOR_BBOX_COLOR);
renderer.polygon(p.getTransformedVertices());
// Rectangle r = a.getBBox().getBoundingRectangle();
// renderer.rect(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
if (polygonalNavGraph != null) {
renderer.setColor(WALKZONE_COLOR);
renderer.polygon(polygonalNavGraph.getWalkZone().getTransformedVertices());
// DRAW LINEs OF SIGHT
renderer.setColor(Color.WHITE);
ArrayList<NavNodePolygonal> nodes = polygonalNavGraph.getGraphNodes();
for (NavNodePolygonal n : nodes) {
for (NavNode n2 : n.neighbors) {
renderer.line(n.x, n.y, ((NavNodePolygonal) n2).x, ((NavNodePolygonal) n2).y);
}
}
}
renderer.end();
}
/**
* Sets polygon with repeating texture region, the size of repeating grid is equal to region size
*
* @param region - region to repeat
* @param vertices - cw vertices of polygon
* @param density - number of regions per polygon width bound
*/
public void setPolygon(TextureRegion region, float[] vertices, float density) {
this.region = region;
vertices = offset(vertices);
Polygon polygon = new Polygon(vertices);
Polygon tmpPoly = new Polygon();
Polygon intersectionPoly = new Polygon();
EarClippingTriangulator triangulator = new EarClippingTriangulator();
int idx;
Rectangle boundRect = polygon.getBoundingRectangle();
if (density == -1) density = boundRect.getWidth() / region.getRegionWidth();
float regionAspectRatio = (float) region.getRegionHeight() / (float) region.getRegionWidth();
cols = (int) (Math.ceil(density));
gridWidth = boundRect.getWidth() / density;
gridHeight = regionAspectRatio * gridWidth;
rows = (int) Math.ceil(boundRect.getHeight() / gridHeight);
for (int col = 0; col < cols; col++) {
for (int row = 0; row < rows; row++) {
float[] verts = new float[8];
idx = 0;
verts[idx++] = col * gridWidth;
verts[idx++] = row * gridHeight;
verts[idx++] = (col) * gridWidth;
verts[idx++] = (row + 1) * gridHeight;
verts[idx++] = (col + 1) * gridWidth;
verts[idx++] = (row + 1) * gridHeight;
verts[idx++] = (col + 1) * gridWidth;
verts[idx] = (row) * gridHeight;
tmpPoly.setVertices(verts);
Intersector.intersectPolygons(polygon, tmpPoly, intersectionPoly);
verts = intersectionPoly.getVertices();
if (verts.length > 0) {
parts.add(snapToGrid(verts));
ShortArray arr = triangulator.computeTriangles(verts);
indices.add(arr.toArray());
} else {
// adding null for key consistancy, needed to get col/row from key
// the other alternative is to make parts - IntMap<FloatArray>
parts.add(null);
}
}
}
buildVertices();
}
public static boolean isPointInside(
Polygon polygon, float x, float y, boolean toleranceOnOutside) {
float verts[] = polygon.getTransformedVertices();
boolean inside = false;
float oldX = verts[verts.length - 2];
float oldY = verts[verts.length - 1];
float oldSqDist = Vector2.dst2(oldX, oldY, x, y);
for (int i = 0; i < verts.length; i += 2) {
float newX = verts[i];
float newY = verts[i + 1];
float newSqDist = Vector2.dst2(newX, newY, x, y);
if (oldSqDist
+ newSqDist
+ 2.0f * Math.sqrt(oldSqDist * newSqDist)
- Vector2.dst2(newX, newY, oldX, oldY)
< TOLERANCE_IS_POINT_INSIDE) return toleranceOnOutside;
float leftX = newX;
float leftY = newY;
float rightX = oldX;
float rightY = oldY;
if (newX > oldX) {
leftX = oldX;
leftY = oldY;
rightX = newX;
rightY = newY;
}
if (leftX < x
&& x <= rightX
&& (y - leftY) * (rightX - leftX) < (rightY - leftY) * (x - leftX)) inside = !inside;
oldX = newX;
oldY = newY;
oldSqDist = newSqDist;
}
return inside;
}
public static boolean isVertexConcave(Polygon poly, int index) {
float verts[] = poly.getTransformedVertices();
float currentX = verts[index];
float currentY = verts[index + 1];
float nextX = verts[(index + 2) % verts.length];
float nextY = verts[(index + 3) % verts.length];
float previousX = verts[index == 0 ? verts.length - 2 : index - 2];
float previousY = verts[index == 0 ? verts.length - 1 : index - 1];
float leftX = currentX - previousX;
float leftY = currentY - previousY;
float rightX = nextX - currentX;
float rightY = nextY - currentY;
float cross = (leftX * rightY) - (leftY * rightX);
return cross < 0;
}
@Override
public void start() {
OwnedObjectData data = new OwnedObjectData();
data.drawAfter = true;
if (bullet.getTicksAlive() < 20) animationPlaying = true;
createTick = game.getTick();
bullet.addOwnedObject(this, data);
final Sprite current = (Sprite) this.ani.getKeyFrame(getTicksAlive());
Polygon hitbox = bullet.getHitbox();
Rectangle rect =
hitbox != null ? hitbox.getBoundingRectangle() : current.getBoundingRectangle();
final float modifier = 3f;
float width = rect.getWidth() * modifier;
float height = rect.getHeight() * modifier;
final float scaleX = width / current.getWidth();
final float scaleY = height / current.getHeight();
current.setScale(scaleX, scaleY);
current.setRotation(bullet.getRotationDeg());
current.setOriginCenter();
Color c = bullet.getDeletionColor().cpy();
float min = Math.min(c.g, Math.min(c.r, c.b));
c.r -= min;
c.g -= min;
c.b -= min;
float mul = 0.8f;
float start = (1f - mul) + 0.3f;
Color color = new Color(start + (c.r * mul), start + (c.g * mul), start + (c.b * mul), 0f);
current.setColor(color);
current.setAlpha(1f);
final SaveableObject<ScaleAlphaPhaseAnimation> sani =
new SaveableObject<ScaleAlphaPhaseAnimation>();
Getter<Sprite> getter =
new Getter<Sprite>() {
@Override
public Sprite get() {
Sprite current = (Sprite) ani.getKeyFrame(getTicksAlive());
int over = 5;
int ticks = (int) ((time.toTicks() - over) - getTicksAlive());
double mul = 1f - (ticks <= 0 ? -(float) ticks / over : 0f);
ScaleAlphaPhaseAnimation ani = sani.getObject();
if (ani == null) return current;
if (ticks <= 0) {
animationPlaying = false;
ani.setAlpha((float) Math.max(0, mul));
}
current.setPosition(
bullet.getX() - current.getWidth() / 2f, bullet.getY() - current.getHeight() / 2f);
current.setOriginCenter();
current.setRotation(bullet.getRotationDeg());
return current;
}
};
final ScaleAlphaPhaseAnimation ani = new ScaleAlphaPhaseAnimation(getter, bullet);
sani.setObject(ani);
ani.setTime(time);
ani.setAddedScale(scaleX * 3f, scaleY * 3f);
ani.setAlpha(-0.1f);
ani.start();
bullet.removeOwnedObject(ani);
bullet.addOwnedObject(ani, data);
}
protected void loadObject(MapLayer layer, Element element) {
if (element.getName().equals("object")) {
MapObject object = null;
int x = element.getIntAttribute("x", 0);
int y =
(yUp
? mapHeightInPixels - element.getIntAttribute("y", 0)
: element.getIntAttribute("y", 0));
int width = element.getIntAttribute("width", 0);
int height = element.getIntAttribute("height", 0);
if (element.getChildCount() > 0) {
Element child = null;
if ((child = element.getChildByName("polygon")) != null) {
String[] points = child.getAttribute("points").split(" ");
float[] vertices = new float[points.length * 2];
for (int i = 0; i < points.length; i++) {
String[] point = points[i].split(",");
vertices[i * 2] = Integer.parseInt(point[0]);
vertices[i * 2 + 1] = Integer.parseInt(point[1]);
if (yUp) {
vertices[i * 2 + 1] *= -1;
}
}
Polygon polygon = new Polygon(vertices);
polygon.setPosition(x, y);
object = new PolygonMapObject(polygon);
} else if ((child = element.getChildByName("polyline")) != null) {
String[] points = child.getAttribute("points").split(" ");
float[] vertices = new float[points.length * 2];
for (int i = 0; i < points.length; i++) {
String[] point = points[i].split(",");
vertices[i * 2] = Integer.parseInt(point[0]);
vertices[i * 2 + 1] = Integer.parseInt(point[1]);
if (yUp) {
vertices[i * 2 + 1] *= -1;
}
}
Polyline polyline = new Polyline(vertices);
polyline.setPosition(x, y);
object = new PolylineMapObject(polyline);
} else if ((child = element.getChildByName("ellipse")) != null) {
object = new EllipseMapObject(x, yUp ? y - height : y, width, height);
}
}
if (object == null) {
object = new RectangleMapObject(x, yUp ? y - height : y, width, height);
}
object.setName(element.getAttribute("name", null));
String type = element.getAttribute("type", null);
if (type != null) {
object.getProperties().put("type", type);
}
int gid = element.getIntAttribute("gid", -1);
if (gid != -1) {
object.getProperties().put("gid", gid);
}
object.getProperties().put("x", x);
object.getProperties().put("y", yUp ? y - height : y);
object.setVisible(element.getIntAttribute("visible", 1) == 1);
Element properties = element.getChildByName("properties");
if (properties != null) {
loadProperties(object.getProperties(), properties);
}
layer.getObjects().add(object);
}
}
private void calculateVertices() {
shape.setVertices(
new float[] {
x, y, x, y + hRatio * 110, x + 735 * hRatio, y + hRatio * 110, x + 625 * hRatio, y
});
}
public boolean contains(float x, float y) {
if (hidden || !click_enabled) return false;
return shape.contains(x, y);
}