// 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;
  }
Exemple #2
0
  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);
 }