コード例 #1
0
ファイル: MovingEntity.java プロジェクト: ZePiNgOo/Mouglotte
    /**
     * Gets whether or not this sensor senses a Pedestrian.
     *
     * @param tileMap the PedestrianTileBasedMap to use, to get the TileState, and the resulting
     *     list of Pedestrians in that tile
     * @return true if a Pedestrian is detected, false otherwise.
     */
    public MovingEntity relativePointSensesEntity(GameMap map) {

      MovingEntity entitySensed = null;

      // Get the point of the entity that may encounter an obstacle
      Point2D.Float relativePoint = this.entity.getRelativePointFromCenter(rx, ry);

      // Get the tile this point is in
      Tile tileSensed =
          map.getTile(
              (int) (relativePoint.x / GameMap.TILE_SIZE),
              (int) (relativePoint.y / GameMap.TILE_SIZE));

      // Search for an entity in this tile
      if (tileSensed != null) {
        LinkedList<Entity> entities = tileSensed.getEntities();

        for (Entity e : entities) {
          if (Math.hypot(relativePoint.x - e.getX(), relativePoint.y - e.getX()) <= SENSOR_RADIUS) {
            entitySensed = (MovingEntity) e;
            break;
          }
        }
      }

      return entitySensed;
    }
コード例 #2
0
  public double getNetGravAccel(double x1, double y1, char component, Entity e) {
    double net = 0;

    if (ents.size() <= 1) return 0;

    try {
      for (Entity other : ents) {
        double x2 = other.getX();
        double y2 = other.getY();
        if (x1 == x2 && y1 == y2) // if distance is 0 (testing itself) then it will divide by 0
        continue;
        double distance = Util.distance(x1, y1, x2, y2);
        // if(Refs.sim.isCollisionType(Simulation.NONCOLLIDE)) //if current collision type is
        // noncollide
        if (Util.areColliding(e, other)) // if colliding, no gravitational effect
        continue;
        double accel = 0;
        accel = other.getMass() / Math.pow(distance, 2);
        double proportion = 1;
        if (component == 'x') proportion = ((x2 - x1)) / distance;
        if (component == 'y') proportion = ((y2 - y1)) / distance;
        net += accel * proportion;
      }
    } catch (Exception ex) {
    }

    return Refs.sim.getGravitationConstant() * net;
  }
コード例 #3
0
  /** @see org.newdawn.asteroids.entity.Entity#collides(org.newdawn.asteroids.entity.Entity) */
  public boolean collides(Entity other) {
    // We're going to use simple circle collision here since we're
    // only worried about 2D collision.
    //
    // Normal math tells us that if the distance between the two
    // centres of the circles is less than the sum of their radius
    // then they collide. However, working out the distance between
    // the two would require a square root (Math.sqrt((dx*dx)+(dy*dy))
    // which could be quite slow.
    //
    // Instead we're going to square the sum of their radius and compare
    // that against the un-rooted value. This is equivilent but
    // much faster

    // Get the size of the other entity and combine it with our
    // own, giving the range of collision. Square this so we can
    // compare it against the current distance.
    float otherSize = other.getSize();
    float range = (otherSize + getSize());
    range *= range;

    // Get the distance on X and Y between the two entities, then
    // find the squared distance between the two.
    float dx = getX() - other.getX();
    float dy = getY() - other.getY();
    float distance = (dx * dx) + (dy * dy);

    // if the squared distance is less than the squared range
    // then we've had a collision!
    return (distance <= range);
  }
コード例 #4
0
ファイル: Round.java プロジェクト: TeamPochard/Assessment-3
  /**
   * Spawns a mob somewhere on the map. Ensures it doesn't intersect anything and is on a spawn tile
   *
   * @param mob
   * @return
   */
  public boolean spawnMob(Mob mob) {
    float x = mob.getX();
    float y = mob.getY();
    TextureSet textureSet = mob.getWalkingTextureSet();

    // Check mob isn't out of bounds.
    if (x < 0
        || x > getMapWidth() - textureSet.getWidth()
        || y > getMapHeight() - textureSet.getHeight()) {
      return false;
    }

    // Check mob doesn't intersect anything.
    for (Entity entity : entities) {
      if (entity instanceof Character
          && (mob.intersects(entity.getX(), entity.getY(), entity.getWidth(), entity.getHeight())
              || mob.collidesX(0)
              || mob.collidesY(0))) {
        return false;
      }
    }

    if (getSpawnLayer().getCell((int) x / getTileWidth(), (int) y / getTileHeight()) == null) {
      return false;
    }

    entities.add(mob);
    return true;
  }
コード例 #5
0
  public void setEntitys(ArrayList<Entity> realEntities) {
    for (Entity e : realEntities) {

      JsonEntity JE = new JsonEntity(e.getX(), e.getY(), e.isSolid(), e.getClass().getName());
      if (e.isSign()) {
        JE.setSignText(e.getSignText());
      }

      entities.add(JE);
    }
  }
コード例 #6
0
ファイル: Camera.java プロジェクト: kieve/Archive
  /** Initialise the Camera variables to the player position. */
  private void initToPlayerPosition() {
    // Cycle through all of the map objects
    // initialise the player when the player object is found
    for (int i = 0; i < map.getObjectGroupCount(); i++) {
      for (int j = 0; j < map.getObjectCount(i); j++) {
        if (map.getObjectName(i, j).equalsIgnoreCase("Player")) {
          player.setX(map.getObjectX(i, j) + (player.getWidth() / 2));
          player.setY(map.getObjectY(i, j));
          this.setPlayerStartXY(player.getX(), player.getY());
        }
      }
    }
    vPlayerX = player.getX();
    vPlayerY = player.getY();

    lastPlayerX = (int) vPlayerX / tileWidth;
    lastPlayerY = (int) vPlayerY / tileHeight;
    curPlayerX = lastPlayerX;
    curPlayerY = lastPlayerY;
  }
コード例 #7
0
ファイル: OOWorld.java プロジェクト: perek586/projekt
  private void drawHealthBar(Graphics g, Entity entity, int xOffset, int yOffset) {
    int width = entity.getTexture().getWidth();
    float xPos = entity.getX() + xOffset;

    int height = entity.getTexture().getHeight();
    float yPos = entity.getY() + yOffset + height;

    g.setColor(new Color(200, 0, 0));
    g.fillRect(xPos, yPos, width, 3);
    g.setColor(new Color(0, 200, 0));
    g.fillRect(xPos, yPos, width * (entity.getHealth() / entity.getMaxHealth()), 3);
  }
コード例 #8
0
ファイル: Round.java プロジェクト: TeamPochard/Assessment-3
  /**
   * Creates a mob and adds it to the list of entities, but only if it doesn't intersect with
   * another character.
   *
   * @param x the initial x coordinate
   * @param y the initial y coordinate
   * @param health the initial health of the mob
   * @param textureSet the texture set to use
   * @param speed how fast the mob moves in pixels per second
   * @return true if the mob was successfully added, false if there was an intersection and the mob
   *     wasn't added
   */
  public boolean createMob(
      Mob mob, float x, float y, int health, TextureSet textureSet, int speed) {

    // Check mob isn't out of bounds.
    if (x < 0
        || x > getMapWidth() - textureSet.getWidth()
        || y > getMapHeight() - textureSet.getHeight()) {
      return false;
    }

    // Check mob doesn't intersect anything.
    for (Entity entity : entities) {
      if (entity instanceof Character
          && (mob.intersects(entity.getX(), entity.getY(), entity.getWidth(), entity.getHeight())
              || mob.collidesX(0)
              || mob.collidesY(0))) {
        return false;
      }
    }

    entities.add(mob);
    return true;
  }
コード例 #9
0
 public void checkCollisions(Entity e) {
   try {
     for (Entity other : ents)
       if (e != other) {
         if (Refs.sim.isCollisionType(Simulation.COLLIDE)) { // collision type collide
           try {
             // e.subliminalUpdate();
             if (!other.hasCheckedCollisions() && !other.shouldKill())
               if (Util.areColliding(e, other)) {
                 // e.subliminalUpdate();
                 e.collide(other, 1);
                 //									other.collide(e, 1);
                 while (Util.areColliding(e, other)) {
                   e.subliminalUpdate();
                   other.subliminalUpdate();
                 }
                 //									e.subliminalUpdate();
                 //									other.subliminalUpdate();
                 continue;
               }
             throw new Exception();
           } catch (Exception ex) {
           }
         } else if (Refs.sim.isCollisionType(Simulation.ABSORB)) { // collision type absorb
           if (!other.hasCheckedCollisions() && !other.shouldKill())
             if (Util.areColliding(e, other)) {
               Collision coll = Util.getCollisionType(e, other);
               // if collision is between 2 balls
               if (coll == Collision.BALL_X_BALL) {
                 e.setKillMe(true);
                 other.setKillMe(true);
                 Ball product =
                     new Ball(
                         (int) Util.average(e.getX(), other.getX(), e.getMass(), other.getMass()),
                         (int) Util.average(e.getY(), other.getY(), e.getMass(), other.getMass()),
                         (int)
                             Math.sqrt(
                                 Math.pow(e.getRadius(), 2) + Math.pow(other.getRadius(), 2)),
                         (int)
                             Util.average(e.getVX(), other.getVX(), e.getMass(), other.getMass()),
                         (int)
                             Util.average(e.getVY(), other.getVY(), e.getMass(), other.getMass()),
                         Util.average(
                             e.getColor(), other.getColor(), e.getMass(), other.getMass()));
                 purgatory.add(product);
                 // if collision is between a ball and a black hole
               } else if (coll == Collision.BALL_X_BH) {
                 if (e instanceof Ball) e.setKillMe(true);
                 else other.setKillMe(true);
                 // if collision is between a black hole and a black hole
               } else if (coll == Collision.BH_X_BH) {
                 e.setKillMe(true);
                 other.setKillMe(true);
                 BlackHole product =
                     new BlackHole(
                         (int) Util.average(e.getX(), other.getX(), e.getMass(), other.getMass()),
                         (int) Util.average(e.getY(), other.getY(), e.getMass(), other.getMass()),
                         (int)
                             Math.sqrt(
                                 Math.pow(e.getRadius(), 2) + Math.pow(other.getRadius(), 2)));
                 purgatory.add(product);
               }
             }
         }
       }
   } catch (Exception ex) {
   }
   e.setCheckedCollisions(true);
 }
コード例 #10
0
ファイル: Round.java プロジェクト: TeamPochard/Assessment-3
  /**
   * Updates all entities in this Round.
   *
   * @param delta the time elapsed since the last update
   */
  public void update(float delta) {

    powerUpManager.update(delta);
    floatyNumbersManager.update(delta);

    if (objective != null) {
      objective.update(delta);

      if (objective.getStatus() == Objective.OBJECTIVE_COMPLETED) {
        parent.showWinScreen(player.getScore());
      } else if (player.isDead()) {
        parent.showLoseScreen();
      }
    }

    // int updateNumber =0, totalNumber=entities.size(), numMobs=0;
    for (int i = 0; i < entities.size(); i++) {
      Entity entity = entities.get(i);
      /*            if(entity instanceof Mob)
      numMobs++;*/

      if (entity.isRemoved()) {
        if (entity instanceof Mob && ((Mob) entity).isDead()) {
          int score =
              (int)
                  (((Mob) entity).getScore()
                      * (powerUpManager.getIsActive(PowerupManager.powerupTypes.SCORE_MULTIPLIER)
                          ? Player.PLAYER_SCORE_MULTIPLIER
                          : 1));
          player.addScore(score);
          floatyNumbersManager.createScoreNumber(score, entity.getX(), entity.getY());
          if (objective.getObjectiveType() == Objective.objectiveType.BOSS) {
            spawnRandomMobs(1, 0, 0, 1000, 1000);
          }
        }

        entities.remove(i);
      } else if ((entity.distanceTo(player.getX(), player.getY()) < UPDATE_DISTANCE_X)
          && (entity.distanceTo(player.getX(), player.getY()) < UPDATE_DISTANCE_Y)) {
        // Don't bother updating entities that aren't on screen.
        entity.update(delta);
        // updateNumber++;
      }
    }

    if (Gdx.input.isKeyJustPressed(Input.Keys.P)) {
      for (int x = 0; x < 1000; x++) {
        createProjectile(
            MathUtils.random(300, 1500),
            MathUtils.random(300, 1500),
            MathUtils.random(300, 1500),
            MathUtils.random(300, 1500),
            500,
            0,
            0,
            0,
            player);
      }
    }
    // System.out.println("total:"+totalNumber+" updated:"+updateNumber+" numMobs:"+numMobs);
  }
コード例 #11
0
  public void draw(Batch batch, float alpha, Entity entity) {
    this.update();
    if (entity instanceof Protagonist) {
      Protagonist bernard = (Protagonist) entity;
      //            if (entity.textureRegion.isFlipX()) {
      //                temp = animation.getKeyFrame(elapsed);
      //                temp.flip(true, false);
      //                batch.draw(animation.getKeyFrame(elapsed), entity.getX() -
      // Constants.TILEDIMENSION * width, entity.getY(), Constants.TILEDIMENSION * width,
      // Constants.TILEDIMENSION * height);
      //                temp.flip(true, false);
      //            } else {
      //                batch.draw(animation.getKeyFrame(elapsed), entity.getX() +
      // Constants.TILEDIMENSION, entity.getY(), Constants.TILEDIMENSION * width,
      // Constants.TILEDIMENSION * height);
      //            }
      if (bernard.getDirection() == Constants.Direction.LEFT) {
        batch.draw(
            animation.getKeyFrame(elapsed),
            entity.getX() - 50,
            entity.getY() - 10,
            Constants.TILEDIMENSION / 2,
            Constants.TILEDIMENSION / 2,
            Constants.TILEDIMENSION * width + 50,
            Constants.TILEDIMENSION * height,
            1,
            1,
            180);
      } else if (bernard.getDirection() == Constants.Direction.RIGHT) {
        batch.draw(
            animation.getKeyFrame(elapsed),
            entity.getX() + Constants.TILEDIMENSION,
            entity.getY(),
            Constants.TILEDIMENSION * width,
            Constants.TILEDIMENSION * height);
      } else if (bernard.getDirection() == Constants.Direction.UP) {
        batch.draw(
            animation.getKeyFrame(elapsed),
            entity.getX(),
            entity.getY() + Constants.TILEDIMENSION,
            Constants.TILEDIMENSION / 2,
            Constants.TILEDIMENSION / 2,
            Constants.TILEDIMENSION * width + 50,
            Constants.TILEDIMENSION * height,
            1,
            1,
            90);
      } else if (bernard.getDirection() == Constants.Direction.DOWN) {
        batch.draw(
            animation.getKeyFrame(elapsed),
            entity.getX(),
            entity.getY() - Constants.TILEDIMENSION,
            Constants.TILEDIMENSION / 2,
            Constants.TILEDIMENSION / 2,
            Constants.TILEDIMENSION * width + 50,
            Constants.TILEDIMENSION * height,
            1,
            1,
            -90);
      }

      if (bernard.getLightBarrierLimit() > 0 && elapsed >= 0.25f) {
        elapsedLight += Gdx.graphics.getDeltaTime();
        //                if (bernard.textureRegion.isFlipX()) {
        //                    temp = light.getKeyFrame(elapsedLight);
        //                    temp.flip(true, false);
        //                    batch.draw(light.getKeyFrame(elapsedLight), bernard.getX() -
        // Constants.TILEDIMENSION * width, bernard.getY(), Constants.TILEDIMENSION * width,
        // Constants.TILEDIMENSION * height);
        //                    temp.flip(true, false);
        //                } else {
        //                    batch.draw(light.getKeyFrame(elapsedLight), bernard.getX() +
        // Constants.TILEDIMENSION, bernard.getY(), Constants.TILEDIMENSION * width,
        // Constants.TILEDIMENSION * height);
        //                }
        if (bernard.getDirection() == Constants.Direction.LEFT) {
          batch.draw(
              light.getKeyFrame(elapsedLight),
              entity.getX() - 50,
              entity.getY() - 5,
              Constants.TILEDIMENSION / 2,
              Constants.TILEDIMENSION / 2,
              Constants.TILEDIMENSION * width + 50,
              Constants.TILEDIMENSION * height,
              1,
              1,
              180);
        } else if (bernard.getDirection() == Constants.Direction.RIGHT) {
          batch.draw(
              light.getKeyFrame(elapsedLight),
              entity.getX() + Constants.TILEDIMENSION,
              entity.getY(),
              Constants.TILEDIMENSION * width,
              Constants.TILEDIMENSION * height);
        } else if (bernard.getDirection() == Constants.Direction.UP) {
          batch.draw(
              light.getKeyFrame(elapsedLight),
              entity.getX(),
              entity.getY() + 50,
              Constants.TILEDIMENSION / 2,
              Constants.TILEDIMENSION / 2,
              Constants.TILEDIMENSION * width + 50,
              Constants.TILEDIMENSION * height,
              1,
              1,
              90);
        } else if (bernard.getDirection() == Constants.Direction.DOWN) {
          batch.draw(
              light.getKeyFrame(elapsedLight),
              entity.getX(),
              entity.getY() - 50,
              Constants.TILEDIMENSION / 2,
              Constants.TILEDIMENSION / 2,
              Constants.TILEDIMENSION * width + 50,
              Constants.TILEDIMENSION * height,
              1,
              1,
              -90);
        }

        if (light.isAnimationFinished(elapsedLight)) {
          bernard.setLightBarrierLimit(bernard.getLightBarrierLimit() - 1);
          //                    String l = String.valueOf(bernard.getLightBarrierLimit());
          //                    Gdx.app.log("LightBarrier", l);
          if (bernard.getLightBarrierLimit() == 0) {
            bernard.setExecuteLightBarrier(false);
            bernard.lightningInfusionCooldown = 5;
          }
          elapsedLight = 0f;
        }
      }
    }
  }
コード例 #12
0
ファイル: DrawPanel.java プロジェクト: bungaca/abstools
  public void drawBuffer() {
    Graphics2D b = buffer.createGraphics(); // DrawPanel
    Graphics2D pl_b = buffer.createGraphics();
    Graphics2D pl_c = buffer.createGraphics();
    rkt = buffer.createGraphics();
    AffineTransform rkt_aff = new AffineTransform();
    Graphics2D envi[] = new Graphics2D[amountEnv];
    AffineTransform enviTrans[] = new AffineTransform[amountEnv];

    b.setColor(Color.BLACK);
    b.fillRect(0, 0, w, h);

    // #if (Default)
    // @
    // #elif (Blue_White)
    // @        	ii_bg = new ImageIcon("imgs/Hintergrund/HgBlauWeiss1.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Blue_White_Green)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/HgBlauWeissGruen.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Purple_White)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/HgLilaWeiss.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Glass)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundglass05.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Lava)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundlava01.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Limba)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundlimba.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Old)
    ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundoldpnt01.gif");
    img_bg = ii_bg.getImage();
    b.drawImage(img_bg, w, w, this);
    // #elif (Ov_Paper)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundov_paper.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Paper)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundpaper05.gif");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Univ)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrunduniv01.jpg");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Water)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundwater01.jpg");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #elif (Water_2)
    // @            ii_bg = new ImageIcon("imgs/Hintergrund/Hintergrundwater05.jpg");
    // @            img_bg = ii_bg.getImage();
    // @            b.drawImage(img_bg, w, w, this);
    // #endif

    b.setColor(Color.gray);
    b.fillRect(0, 0, w, 25); // oben
    b.fillRect(0, h - 50, w, 25); // unten
    b.fillRect(0, 0, 25, h); // links
    b.fillRect(w - 35, 0, 30, h); // rechts
    b.setColor(Color.WHITE);

    // rocket
    // #if (tar)
    // #if (Rectangle)
    // @               if (current_Player.isRocket()){
    // @                   rkt_aff.rotate(current_Player.getDegree(), sch.getX(), sch.getY());
    // @                   rkt.setTransform(rkt_aff);
    // @                   System.out.println("Rok X:"+sch.getX()+" Rok Y:"+sch.getY());
    // @                   rkt.drawRect(sch.getX()+ current_Player.getWidth()/2, sch.getY() +
    // current_Player.getHeight()/2, kaliber, kaliber);} // Rocket 4Eck
    // #endif
    // #if (Oval)
    // @               if (current_Player.isRocket()){
    // @                   b.drawOval(sch.getX()+ current_Player.getWidth()/2, sch.getY() +
    // current_Player.getHeight()/2, kaliber, kaliber);} // Rocket Oval
    // #endif
    // #if (aa31)
    // @                 if (current_Player.isRocket()){
    // @                     try {
    // @                        rocketFire = ImageIO.read(new File("imgs/aa31.gif"));
    // @                        rkt_aff.rotate(current_Player.getDegree(), sch.getX(), sch.getY());
    // @                        rkt.setTransform(rkt_aff);
    // @                        rkt.drawImage(rocketFire, null, (int)sch.getX(), (int)sch.getY());
    // @                        //rkt.drawImage(rocketFire, null, (int)current_Player.getX(),
    // (int)current_Player.getY());
    // @                    } catch (IOException e) {
    // @                    }
    // @                 }
    // #endif
    // #if (Portal)
    // @                 if (current_Player.isRocket()){
    // @                     try {
    // @                        rocketFire = ImageIO.read(new File("imgs/portal.gif"));
    // @                        rkt_aff.rotate(current_Player.getDegree(), sch.getX(), sch.getY());
    // @                        rkt.setTransform(rkt_aff);
    // @                        rkt.drawImage(rocketFire, null,
    // sch.getX()+current_Player.getWidth()/2, sch.getY()+current_Player.getHeight()/2);
    // @                     } catch (IOException e) {
    // @                     }
    // @                 }
    // #endif
    // #if (Nino)
    // @                 if (current_Player.isRocket()){
    // @                     try {
    // @                        rocketFire = ImageIO.read(new File("imgs/nino.gif"));
    // @                        rkt_aff.rotate(current_Player.getDegree(), sch.getX(), sch.getY());
    // @                        rkt.setTransform(rkt_aff);
    // @                        rkt.drawImage(rocketFire, null,
    // sch.getX()+current_Player.getWidth()/2, sch.getY()+current_Player.getHeight()/2);
    // @                     } catch (IOException e) {
    // @                     }
    // @                 }
    // #endif
    // #endif

    for (int i = 0; i <= amountEnv - 1; i++) {
      envi[i] = buffer.createGraphics();
      enviTrans[i] = new AffineTransform();
      envi[i].setTransform(enviTrans[i]);
      envi[i].drawImage(env[i].getImg(), env[i].getX(), env[i].getY(), this);
    }

    for (int i = 0; i < 8; i++) {
      if (powerUps[i].isAktiv()) {
        b.setColor(powerUps[i].getCol());
        b.drawImage(powerUps[i].getImg(), powerUps[i].getX(), powerUps[i].getY(), this);
      }
    }

    b.setColor(Color.WHITE);
    b.drawString("BP: " + current_Player.getBp(), 10, 20);
    b.drawString("TP P1/P2: " + player_1.getTp() + " / " + player_2.getTp(), 100, 20);

    if (current_Player.getSch().getEnd_X() != 0 && current_Player.getSch().getEnd_Y() != 0) {
      b.setColor(Color.YELLOW);
      b.drawLine(
          (int) current_Player.getSch().getStart_X(),
          (int) current_Player.getSch().getStart_Y(),
          (int) current_Player.getSch().getEnd_X(),
          (int) current_Player.getSch().getEnd_Y());
      b.setColor(Color.WHITE);
      for (int i = 0; i < current_Player.getSch().getArImg().length; i++) {
        if (current_Player.getSch().getArImg()[i] != null && current_Player.getSch().isIsActive()) {
          b.drawImage(
              current_Player.getSch().getArImg()[i],
              (int) current_Player.getSch().getEnd_X()
                  - current_Player.getSch().getArImg()[i].getWidth(this) / 2,
              (int) current_Player.getSch().getEnd_Y()
                  - current_Player.getSch().getArImg()[i].getHeight(this) / 2,
              (int)
                  (current_Player.getSch().getArImg()[i].getWidth(this)
                      * (current_Player.getSch().getSpeed() / 150)),
              (int)
                  (current_Player.getSch().getArImg()[i].getHeight(this)
                      * (current_Player.getSch().getSpeed() / 150)),
              this);
          if (timeCounter == 75) {
            System.out.println("----------------------><---------------------");
            if (player_1
                .getBounds()
                .intersects(
                    (int) current_Player.getSch().getEnd_X()
                        - current_Player.getSch().getArImg()[i].getWidth(this) / 2,
                    (int) current_Player.getSch().getEnd_Y()
                        - current_Player.getSch().getArImg()[i].getHeight(this) / 2,
                    (int)
                        (current_Player.getSch().getArImg()[i].getWidth(this)
                            * (current_Player.getSch().getSpeed() / 150)),
                    (int)
                        (current_Player.getSch().getArImg()[i].getHeight(this)
                            * (current_Player.getSch().getSpeed() / 150)))) {
              player_1.setTp(player_1.getTp() - (int) current_Player.getSch().getSpeed() / 4);
              System.out.println("----------------------> P1 <---------------------");
            }
            if (player_2
                .getBounds()
                .intersects(
                    (int) current_Player.getSch().getEnd_X()
                        - current_Player.getSch().getArImg()[i].getWidth(this) / 2,
                    (int) current_Player.getSch().getEnd_Y()
                        - current_Player.getSch().getArImg()[i].getHeight(this) / 2,
                    (int)
                        (current_Player.getSch().getArImg()[i].getWidth(this)
                            * (current_Player.getSch().getSpeed() / 150)),
                    (int)
                        (current_Player.getSch().getArImg()[i].getHeight(this)
                            * (current_Player.getSch().getSpeed() / 150)))) {
              player_2.setTp(player_2.getTp() - (int) current_Player.getSch().getSpeed() / 4);
              System.out.println("----------------------> P2 <---------------------");
            }
          }
        }
        if (timeCounter >= 150) {
          timeCounter = 0;
          current_Player.getSch().setIsActive(false);
          current_Player.getSch().setEnd_X(0);
          current_Player.getSch().setEnd_Y(0);
        }
        if (current_Player.getSch().isIsActive()) timeCounter += 1;
        System.out.println("timecounter: " + timeCounter);
      }
    }

    if (player_1.getTp() <= 0) b.drawString("SPIELER 2 HAT GEWONNEN !", w / 2, h / 2);
    if (player_2.getTp() <= 0) b.drawString("SPIELER 1 HAT GEWONNEN !", w / 2, h / 2);

    current_Player.setStop(false);
    b.setColor(Color.red);

    AffineTransform a = new AffineTransform();
    a.rotate(
        current_Player.getDegree(),
        current_Player.getX() + current_Player.getWidth() / 2,
        current_Player.getY() + current_Player.getHeight() / 2);
    ((Graphics2D) pl_b).setTransform(a);
    pl_b.drawImage(
        current_Player.getImg(), (int) current_Player.getX(), (int) current_Player.getY(), this);
    System.out.println(
        "P1 X:" + (int) current_Player.getX() + " P1 Y:" + (int) current_Player.getY());
    System.out.println("P1 W:" + current_Player.getWidth() + " P1 H:" + current_Player.getHeight());
    AffineTransform a2 = new AffineTransform();
    a2.rotate(
        other_Player.getDegree(),
        other_Player.getX() + other_Player.getWidth() / 2,
        other_Player.getY() + other_Player.getHeight() / 2);
    ((Graphics2D) pl_c).setTransform(a2);
    pl_c.drawImage(
        other_Player.getImg(), (int) other_Player.getX(), (int) other_Player.getY(), this);

    if (current_Player.isCollision() == true) {
      current_Player.setStop(true);
      if (timecount > 10) {
        b.setColor(Color.WHITE);
        b.drawString("C O L L I S I O N !", (int) w / 2 - 50, (int) h / 2);
        timecount--;
      } else {
        timecount = 0;
        current_Player.setBp(0);
        current_Player.setX(300);
        current_Player.setY(100);
        current_Player.getSch().setEnd_X(1);
        current_Player.getSch().setEnd_Y(1);
        current_Player.getSch().setStart_X(1);
        current_Player.getSch().setStart_Y(1);
      }
      b.dispose();
    }
  }
コード例 #13
0
  /** Updates the enitities position depending on nearest food and attacking */
  public void update() {
    radarEntity.setX(entity.getX());
    radarEntity.setY(entity.getY());
    Entity target = entity.getWorld().getNearbyFood(radarEntity, entity);

    if (entity.getSizeValue() * entity.getBodyParts().size()
        < prevEntityValue * entity.getBodyParts().size()) runAway = true;

    if (!runAway) {
      if (target != null) {

        int xTarget = target.getX();
        int yTarget = target.getY();
        if (target.getType() < 3) {
          entity.setColor(Color.orange);
          entity.setVelocity(MAX_ATTACK_VELOCITY);
          entity.setAcceleration(MAX_ATTACK_ACCELERATION);
          entity.setDeceleration(MAX_ATTACK_ACCELERATION / 2);
          entity.setTarget(xTarget, yTarget);
        } else {
          entity.setColor(Color.white);
          entity.setVelocity(MAX_VELOCITY);
          entity.setAcceleration(MAX_ACCELERATION);
          entity.setDeceleration(MAX_ACCELERATION / 2);
          entity.setTarget(xTarget, yTarget);
        }
      } else {
        entity.setColor(Color.white);
        entity.setVelocity(MAX_VELOCITY);
        entity.setAcceleration(MAX_ACCELERATION);
        entity.setDeceleration(MAX_ACCELERATION / 2);
        currTime = timer.milliTime(); // get the time we are at
        accumulator += currTime - prevTime; // add time taken since last loop to accumulator

        prevTime = currTime; // set new previous time

        if (accumulator >= TIMESTEP_MILLIS) { // while there is an update rate in the accumulator

          boolean bx = rbooleanx.nextBoolean();
          boolean by = rbooleany.nextBoolean();

          int xTarget = entity.getX();
          int yTarget = entity.getY();

          if (bx == true) xTarget += rx.nextInt(RANGE);
          else xTarget += (rx.nextInt(RANGE)) * -1;

          if (by == true) yTarget += ry.nextInt(RANGE);
          else yTarget += (ry.nextInt(RANGE)) * -1;

          entity.setTarget(xTarget, yTarget);
          accumulator = 0;
        }
      }
      prevEntityValue = entity.getSizeValue();
    } else // we're running away
    {
      entity.setColor(Color.blue);
      entity.setVelocity(MAX_ATTACK_VELOCITY);
      entity.setAcceleration(MAX_ATTACK_ACCELERATION);
      currTime = timer.milliTime(); // get the time we are at
      accumulator += currTime - prevTime; // add time taken since last loop to accumulator
      runningTime += currTime - prevTime;
      prevTime = currTime; // set new previous time

      if (accumulator >= TIMESTEP_MILLIS) { // while there is an update rate in the accumulator

        int xTarget = entity.getX();
        int yTarget = entity.getY();

        if (xTarget < 0) xTarget -= FLEE_RANGE;
        else xTarget += FLEE_RANGE;

        if (yTarget < 0) yTarget -= FLEE_RANGE;
        else yTarget += FLEE_RANGE;

        entity.setTarget(xTarget, yTarget);
        accumulator = 0;
      }

      if (runningTime > 10000) {
        runAway = false;
        runningTime = 0;
        prevEntityValue = entity.getSizeValue();
        accumulator = TIMESTEP_MILLIS;
      }
    }
  }
コード例 #14
0
  @EventHandler
  public void onPacketProcess(PacketProcessEvent event) {
    Packet packet = event.getPacket();
    if (packet instanceof Packet5PlayerInventory) {
      Packet5PlayerInventory inventoryPacket = (Packet5PlayerInventory) packet;
      Entity entity = getEntityById(inventoryPacket.entityID);
      if (entity == null || !(entity instanceof LivingEntity)) return;
      LivingEntity livingEntity = (LivingEntity) entity;
      livingEntity.setWornItemAt(inventoryPacket.slot, inventoryPacket.item);
    } else if (packet instanceof Packet8UpdateHealth) {
      Packet8UpdateHealth updateHealthPacket = (Packet8UpdateHealth) packet;
      MainPlayerEntity player = bot.getPlayer();
      player.setHealth(updateHealthPacket.healthMP);
      player.setHunger(updateHealthPacket.food);
    } else if (packet instanceof Packet9Respawn) {
      synchronized (chunks) {
        chunks.clear();
      }
    } else if (packet instanceof Packet20NamedEntitySpawn) {
      Packet20NamedEntitySpawn spawnPacket = (Packet20NamedEntitySpawn) packet;
      PlayerEntity entity = new PlayerEntity(this, spawnPacket.entityId, spawnPacket.name);
      entity.setX(spawnPacket.xPosition / 32D);
      entity.setY(spawnPacket.yPosition / 32D);
      entity.setZ(spawnPacket.zPosition / 32D);
      entity.setYaw(spawnPacket.rotation);
      entity.setPitch(spawnPacket.pitch);
      entity.setWornItemAt(0, new BasicItemStack(spawnPacket.currentItem, 1, 0));
      spawnEntity(entity);
    } else if (packet instanceof Packet21PickupSpawn) {
      Packet21PickupSpawn spawnPacket = (Packet21PickupSpawn) packet;
      ItemEntity entity = new ItemEntity(this, spawnPacket.entityId, spawnPacket.item);
      entity.setX(spawnPacket.xPosition / 32D);
      entity.setY(spawnPacket.yPosition / 32D);
      entity.setZ(spawnPacket.zPosition / 32D);
      spawnEntity(entity);
    } else if (packet instanceof Packet22Collect) {
      Entity entity = getEntityById(((Packet22Collect) packet).collectedEntityId);
      if (entity != null) despawnEntity(entity);
    } else if (packet instanceof Packet23VehicleSpawn) {
      Packet23VehicleSpawn spawnPacket = (Packet23VehicleSpawn) packet;
      Entity entity = null;
      Class<? extends Entity> entityClass = EntityList.getObjectEntityClass(spawnPacket.type);
      if (entityClass == null) return;
      try {
        Constructor<? extends Entity> constructor =
            entityClass.getConstructor(World.class, Integer.TYPE);
        entity = constructor.newInstance(this, spawnPacket.entityId);
      } catch (Exception exception) {
        exception.printStackTrace();
        return;
      }
      entity.setX(spawnPacket.xPosition / 32D);
      entity.setY(spawnPacket.yPosition / 32D);
      entity.setZ(spawnPacket.zPosition / 32D);
      entity.setYaw(0);
      entity.setPitch(0);
      spawnEntity(entity);
    } else if (packet instanceof Packet24MobSpawn) {
      Packet24MobSpawn mobSpawnPacket = (Packet24MobSpawn) packet;
      LivingEntity entity = null;
      Class<? extends LivingEntity> entityClass =
          EntityList.getLivingEntityClass(mobSpawnPacket.type);
      if (entityClass == null) return;
      try {
        Constructor<? extends LivingEntity> constructor =
            entityClass.getConstructor(World.class, Integer.TYPE);
        entity = constructor.newInstance(this, mobSpawnPacket.entityId);
      } catch (Exception exception) {
        exception.printStackTrace();
        return;
      }
      entity.setX(mobSpawnPacket.xPosition / 32D);
      entity.setY(mobSpawnPacket.yPosition / 32D);
      entity.setZ(mobSpawnPacket.zPosition / 32D);
      entity.setYaw((mobSpawnPacket.yaw * 360) / 256F);
      entity.setPitch((mobSpawnPacket.pitch * 360) / 256F);
      entity.setHeadYaw((mobSpawnPacket.headYaw * 360) / 256F);

      if (mobSpawnPacket.getMetadata() != null) entity.updateMetadata(mobSpawnPacket.getMetadata());
      spawnEntity(entity);
    } else if (packet instanceof Packet25EntityPainting) {
      Packet25EntityPainting paintingPacket = (Packet25EntityPainting) packet;
      PaintingEntity entity =
          new PaintingEntity(
              this, paintingPacket.entityId, ArtType.getArtTypeByName(paintingPacket.title));
      entity.setX(paintingPacket.xPosition);
      entity.setY(paintingPacket.yPosition);
      entity.setZ(paintingPacket.zPosition);
      entity.setDirection(paintingPacket.direction);
      spawnEntity(entity);
    } else if (packet instanceof Packet26EntityExpOrb) {

    } else if (packet instanceof Packet29DestroyEntity) {
      Packet29DestroyEntity destroyEntityPacket = (Packet29DestroyEntity) packet;
      for (int id : destroyEntityPacket.entityIds) {
        Entity entity = getEntityById(id);
        if (entity != null) {
          despawnEntity(entity);
          entity.setDead(true);
        }
      }
    } else if (packet instanceof Packet30Entity) {
      Packet30Entity entityPacket = (Packet30Entity) packet;
      Entity entity = getEntityById(entityPacket.entityId);
      if (entity == null) return;
      entity.setX(entity.getX() + (entityPacket.xPosition / 32D));
      entity.setY(entity.getY() + (entityPacket.yPosition / 32D));
      entity.setZ(entity.getZ() + (entityPacket.zPosition / 32D));
      if (packet instanceof Packet31RelEntityMove || packet instanceof Packet33RelEntityMoveLook) {
        entity.setYaw((entityPacket.yaw * 360) / 256F);
        entity.setPitch((entityPacket.pitch * 360) / 256F);
      }
    } else if (packet instanceof Packet34EntityTeleport) {
      Packet34EntityTeleport teleportPacket = (Packet34EntityTeleport) packet;
      Entity entity = getEntityById(teleportPacket.entityId);
      if (entity == null) return;
      entity.setX(teleportPacket.xPosition / 32D);
      entity.setY(teleportPacket.yPosition / 32D);
      entity.setZ(teleportPacket.zPosition / 32D);
      entity.setYaw((teleportPacket.yaw * 360) / 256F);
      entity.setPitch((teleportPacket.pitch * 360) / 256F);
    } else if (packet instanceof Packet35EntityHeadRotation) {
      Packet35EntityHeadRotation headRotatePacket = (Packet35EntityHeadRotation) packet;
      Entity entity = getEntityById(headRotatePacket.entityId);
      if (entity == null || !(entity instanceof LivingEntity)) return;
      ((LivingEntity) entity).setHeadYaw((headRotatePacket.headRotationYaw * 360) / 256F);
    } else if (packet instanceof Packet39AttachEntity) {
      Packet39AttachEntity attachEntityPacket = (Packet39AttachEntity) packet;
      Entity rider = getEntityById(attachEntityPacket.entityId);
      if (rider == null) return;
      Entity riding = null;
      if (attachEntityPacket.vehicleEntityId == -1) {
        if (rider.getRiding() != null) {
          rider.getRiding().setRider(null);
          rider.setRiding(null);
        }
      } else {
        riding = getEntityById(attachEntityPacket.vehicleEntityId);
        if (riding == null) return;
        rider.setRiding(riding);
        riding.setRider(rider);
      }
    } else if (packet instanceof Packet40EntityMetadata) {
      Packet40EntityMetadata metadataPacket = (Packet40EntityMetadata) packet;
      Entity entity = getEntityById(metadataPacket.entityId);
      if (entity == null) return;
      entity.updateMetadata(metadataPacket.getMetadata());
    } else if (packet instanceof Packet43Experience) {
      Packet43Experience experiencePacket = (Packet43Experience) packet;
      MainPlayerEntity player = bot.getPlayer();
      player.setExperienceLevel(experiencePacket.experienceLevel);
      player.setExperienceTotal(experiencePacket.experienceTotal);
    } else if (packet instanceof Packet51MapChunk) {
      if (bot.isMovementDisabled()) return;
      Packet51MapChunk mapChunkPacket = (Packet51MapChunk) packet;
      processChunk(
          mapChunkPacket.x,
          mapChunkPacket.z,
          mapChunkPacket.chunkData,
          mapChunkPacket.bitmask,
          mapChunkPacket.additionalBitmask,
          true,
          mapChunkPacket.biomes);
    } else if (packet instanceof Packet52MultiBlockChange) {
      Packet52MultiBlockChange multiBlockChangePacket = (Packet52MultiBlockChange) packet;
      if (multiBlockChangePacket.metadataArray == null) return;
      DataInputStream datainputstream =
          new DataInputStream(new ByteArrayInputStream(multiBlockChangePacket.metadataArray));
      try {
        for (int i = 0; i < multiBlockChangePacket.size; i++) {
          short word0 = datainputstream.readShort();
          short word1 = datainputstream.readShort();
          int id = (word1 & 0xfff) >> 4;
          int metadata = word1 & 0xf;
          int x = word0 >> 12 & 0xf;
          int z = word0 >> 8 & 0xf;
          int y = word0 & 0xff;
          setBlockIdAt(
              id,
              (multiBlockChangePacket.xPosition * 16) + x,
              y,
              (multiBlockChangePacket.zPosition * 16) + z);
          setBlockMetadataAt(
              metadata,
              (multiBlockChangePacket.xPosition * 16) + x,
              y,
              (multiBlockChangePacket.zPosition * 16) + z);
        }
      } catch (IOException exception) {
        exception.printStackTrace();
      }
    } else if (packet instanceof Packet53BlockChange) {
      Packet53BlockChange blockChangePacket = (Packet53BlockChange) packet;
      setBlockIdAt(
          blockChangePacket.type,
          blockChangePacket.xPosition,
          blockChangePacket.yPosition,
          blockChangePacket.zPosition);
      setBlockMetadataAt(
          blockChangePacket.metadata,
          blockChangePacket.xPosition,
          blockChangePacket.yPosition,
          blockChangePacket.zPosition);
    } else if (packet instanceof Packet56MapChunks) {
      if (bot.isMovementDisabled()) return;
      Packet56MapChunks chunkPacket = (Packet56MapChunks) packet;
      for (int i = 0; i < chunkPacket.primaryBitmap.length; i++)
        processChunk(
            chunkPacket.chunkX[i],
            chunkPacket.chunkZ[i],
            chunkPacket.chunkData[i],
            chunkPacket.primaryBitmap[i],
            chunkPacket.secondaryBitmap[i],
            chunkPacket.skylight,
            true);
    }
  }
コード例 #15
0
  @Override
  public void render(float delta) {
    // update and draw stuff
    Gdx.gl.glClearColor(1, 1, 1, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    camera.update();
    batch.setProjectionMatrix(camera.combined);
    shapes.setProjectionMatrix(camera.combined);

    shapes.begin(ShapeType.Line);
    shapes.setColor(Color.RED);
    for (int x = 0; x < Gdx.graphics.getWidth(); x += Constants.TILE_SIZE) {
      shapes.line(x, 0, x, Gdx.graphics.getHeight());
    }
    for (int y = 0; y < Gdx.graphics.getHeight(); y += Constants.TILE_SIZE) {
      shapes.line(0, y, Gdx.graphics.getWidth(), y);
    }

    shapes.end();

    shapes.begin(ShapeType.Filled);
    shapes.setColor(Color.CYAN);
    for (Entity entity : allEntities) {
      if (entity != null) {
        for (BoundingShape b : entity.getBoundingShapes()) {
          Rectangle2D bounds = b.getShape().getBounds2D();
          shapes.rect(
              (float) bounds.getX() + entity.getX(),
              (float) bounds.getY() + entity.getY(),
              (float) bounds.getWidth(),
              (float) bounds.getHeight());
        }
      }
    }

    shapes.setColor(Color.GREEN);
    for (int x = 0; x < staticGrid.length; x++) {
      for (int y = 0; y < staticGrid[0].length; y++) {
        if (staticGrid[x][y] == 1)
          shapes.rect(
              x * Constants.TILE_SIZE,
              y * Constants.TILE_SIZE,
              Constants.TILE_SIZE,
              Constants.TILE_SIZE);
      }
    }
    shapes.end();

    batch.begin();

    for (Entity entity : allEntities) {
      if (entity != null) {
        if (entity.getSprite() != null) {
          batch.draw(entity.getSprite(), entity.getX(), entity.getY());
        }
      }
    }
    // batch.draw(player.getSprite(), player.getSprite().getX(),
    // player.getSprite().getY(),player.getSprite().getOriginX(),
    //            player.getSprite().getOriginY(),
    //
    // player.getSprite().getWidth(),player.getSprite().getHeight(),player.getSprite().getScaleX(),player.
    //                     getSprite().getScaleY(),player.getSprite().getRotation());

    batch.end();

    batch.begin();
    font.draw(batch, "FPS: " + Gdx.graphics.getFramesPerSecond(), 50, 50);
    font.draw(batch, "Mouse X: " + Gdx.input.getX(), 50, 80);
    font.draw(batch, "Mouse Y: " + Gdx.input.getY(), 50, 110);
    batch.end();
    // debugRenderer.render(world, debugMatrix);
    for (Entity entity : allEntities) {
      if (entity != null) {
        entity.update(delta); // update all entities before handling collisions
      }
    }
    updateQuad();

    ArrayList<BoundingShape> returnObjects = new ArrayList<BoundingShape>();
    for (Entity entity : allEntities) {
      if (entity != null) {
        ArrayList<BoundingShape> bs = entity.getBoundingShapes();
        for (int j = 0; j < bs.size(); j++) {
          returnObjects.clear();
          BoundingShape currentBounding = bs.get(j);
          quad.retrieve(returnObjects, currentBounding);

          for (int x = 0; x < returnObjects.size(); x++) {
            // Run collision detection algorithm between objects
            BoundingShape other = returnObjects.get(x);
            // System.out.println(other.getUserData());
            if (currentBounding.intersects(other)) {
              if (currentBounding.getOwner() != other.getOwner()) {
                currentBounding
                    .getOwner()
                    .collide(
                        new Collision(
                            currentBounding.getOwner(), other.getOwner(), currentBounding, other));
                // System.out.println("Collision: " + currentBounding.getUserData() + " + " +
                // other.getUserData());
              }
            }
          }
        }
        entity.postCollisionUpdate();
      }
    }
  }
コード例 #16
0
ファイル: Camera.java プロジェクト: kieve/Archive
  /**
   * Update Camera variables in the step.
   *
   * @param gc Slick GameContainer.
   * @param delta Time passed since last update.
   * @throws SlickException
   */
  public void update(GameContainer gc, int delta) throws SlickException {

    vPlayerX = player.getX();
    vPlayerY = player.getY();

    if (vPlayerX < (screenWidth / 2)) {
      camX = 0;
      screenRight = screenWidth;
    } else if (vPlayerX > mapWidth - (screenWidth / 2)) {
      camX = screenWidth - mapWidth;
      screenRight = mapWidth;
    } else {
      camX = (int) ((screenWidth / 2) - vPlayerX);
      screenRight = vPlayerX + (screenWidth / 2);
    }
    // Same as above but for 'Y' axis
    if (vPlayerY < (screenHeight / 2)) {
      camY = 0;
      screenDown = screenHeight;
    } else if (vPlayerY > mapHeight - (screenHeight / 2)) {
      camY = screenHeight - mapHeight;
      screenDown = mapHeight;
    } else {
      camY = (int) ((screenHeight / 2) - vPlayerY);
      screenDown = vPlayerY + (screenHeight / 2);
    }

    player.setVisualLocation(vPlayerX, vPlayerY);
    player.update(delta);
    if (!((GameplayState) MainGame.getInstance().getState(GameplayState.ID)).isPaused())
      for (Entity e : entity) e.update(delta);

    vX = (int) player.getVisualX();
    vY = (int) player.getVisualY();

    vAcross = vX / tileWidth;
    vDown = vY / tileHeight;

    curPlayerX = (int) (vPlayerX / tileWidth);
    curPlayerY = (int) (vPlayerY / tileHeight);

    movedIntoOpen = false;
    try {
      if (this.foregroundTiles[lastPlayerX][lastPlayerY] == 1
          && this.foregroundTiles[curPlayerX][curPlayerY] == 0) {
        movedIntoOpen = true;
      }
    } catch (Exception e) {
      // This error occurs when the player character walks off screen,
      // out of the bounds of the tiled map.
    }

    changedPosition = false;
    if (this.curPlayerX != this.lastPlayerX) {
      lastPlayerX = curPlayerX;
      changedPosition = true;
    }
    if (this.curPlayerY != this.lastPlayerY) {
      lastPlayerY = curPlayerY;
      changedPosition = true;
    }

    if (changedPosition) {
      updateForeground = true;
    }
  }