public void LoadTilesWithoutBody(TiledMap tileMap, World world) {

    TiledMapTileLayer layer = (TiledMapTileLayer) tileMap.getLayers().get("Empty");

    float tileSize = layer.getTileHeight();

    for (int row = 0; row < layer.getHeight(); row++) {
      for (int col = 0; col < layer.getWidth(); col++) {
        Cell cell = layer.getCell(col, row);

        if (cell == null || cell.getTile() == null) continue;

        // create

        float x = col * tileSize / B2D.PPM;
        float y = row * tileSize / B2D.PPM;

        int tileType = cell.getTile().getId();
        tileType--;

        if (tileType == 15) {
          GameStats.GameSpawnPosition = new Vector2(x, y);
          Cell c = new Cell();
          layer.setCell(col, row, c);
        }

        if (tileType <= 14) {
          // e element normal
          int id = tileType;
          GameTileRenderer.tlz[col][row] = id;
        }
      }
    }
  }
Beispiel #2
0
 private boolean isCellBlocked(float x, float y) {
   Vector2 newCoords = UtilityMethods.screenToMapCoordinate(new Vector2(x, y));
   // System.out.println("Player: x" + sprite.getX() + " y " + sprite.getY());
   // System.out.println("Tile: x" + newCoords.x + " y " + newCoords.y);
   // sprite.setPosition(newCoords.x, newCoords.y);
   Cell cell =
       collisionLayer.getCell(
           (int) (newCoords.x / collisionLayer.getTileWidth()),
           (int) (newCoords.y / collisionLayer.getTileHeight()));
   // System.out.println(cell);
   return cell != null
       && cell.getTile() != null
       && cell.getTile().getProperties().containsKey("blocked");
 }
 public boolean isTileCollidable(int column, int row) {
   // System.out.println(column + "," + row + " testing");
   Cell tileCell = metaLayer.getCell(column, row);
   if (tileCell != null) {
     TiledMapTile tile = tileCell.getTile();
     MapProperties properties = tile.getProperties();
     if (properties.containsKey("collidable")) {
       Object value = properties.get("collidable");
       if (value.toString().compareTo("1") == 0) {
         return true;
       }
     }
   }
   return false;
 }
 private void _loadSpecialTilesRoutine(TiledMap map) {
   // System.out.println("_loadSpecialTilesRoutine");
   Iterator<TiledMapTile> tiles = map.getTileSets().getTileSet(0).iterator();
   // System.out.println(map.getTileSets().getTileSet(0).size());
   while (tiles.hasNext()) {
     TiledMapTile tile = tiles.next();
     if (tile.getProperties().containsKey("debug")) {
       // System.out.println("debug tile found!!");
       debugCell = new Cell();
       debugCell.setTile(tile);
     } else if (tile.getProperties().containsKey("collidable")) {
       // System.out.println("collidable tile found!!");
       collidableCell = new Cell();
       collidableCell.setTile(tile);
     }
   }
 }
Beispiel #5
0
  private void initCollidableBlocks() {
    layer = (TiledMapTileLayer) map.getLayers().get("Collidable");

    for (int row = 0; row < layer.getHeight(); row++) {
      for (int col = 0; col < layer.getWidth(); col++) {
        Cell cell = layer.getCell(col, row);

        // Checamos para ver se existe algum tile aqui
        if (cell == null || cell.getTile() == null) {
          collidableArea[col][row] = false;
          continue;
        }

        // adicionamos essa posição à collidableBlocks;
        collidableArea[col][row] = true;
      }
    }
  }
Beispiel #6
0
  private void generatePlatforms(String LayerName) {
    TiledMapTileLayer layer = (TiledMapTileLayer) tileMap.getLayers().get(LayerName);

    tileSize = layer.getTileHeight();

    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();

    // iterate over tiles and build box2d objects and chaining them together
    for (int row = 0; row < layer.getHeight(); row++) {
      for (int col = 0; col < layer.getWidth(); col++) {

        Cell cell = layer.getCell(col, row);

        if (cell == null) continue;
        if (cell.getTile() == null) continue;

        bdef.type = BodyType.StaticBody;
        bdef.position.set((col + 0.5f) * tileSize / PPM, (row + 0.5f) * tileSize / PPM);

        ChainShape cs = new ChainShape();
        Vector2[] v = new Vector2[3];
        v[0] = new Vector2(-tileSize / 2 / PPM, -tileSize / 2 / PPM);
        v[1] = new Vector2(-tileSize / 2 / PPM, +tileSize / 2 / PPM);
        v[2] = new Vector2(+tileSize / 2 / PPM, +tileSize / 2 / PPM);

        cs.createChain(v);
        fdef.friction = 0;
        fdef.shape = cs;
        fdef.filter.categoryBits = B2DVars.BIT_BLOCKS;
        fdef.filter.maskBits = B2DVars.BIT_PLAYER;
        fdef.isSensor = false;
        world.createBody(bdef).createFixture(fdef);
      }
    }
  }
 protected Cell createTileLayerCell(
     boolean flipHorizontally, boolean flipVertically, boolean flipDiagonally) {
   Cell cell = new Cell();
   if (flipDiagonally) {
     if (flipHorizontally && flipVertically) {
       cell.setFlipHorizontally(true);
       cell.setRotation(yUp ? Cell.ROTATE_270 : Cell.ROTATE_90);
     } else if (flipHorizontally) {
       cell.setRotation(yUp ? Cell.ROTATE_270 : Cell.ROTATE_90);
     } else if (flipVertically) {
       cell.setRotation(yUp ? Cell.ROTATE_90 : Cell.ROTATE_270);
     } else {
       cell.setFlipVertically(true);
       cell.setRotation(yUp ? Cell.ROTATE_270 : Cell.ROTATE_90);
     }
   } else {
     cell.setFlipHorizontally(flipHorizontally);
     cell.setFlipVertically(flipVertically);
   }
   return cell;
 }
  public void LoadTilesWithBody(TiledMap tileMap, World world) {
    TiledMapTileLayer layer = (TiledMapTileLayer) tileMap.getLayers().get("Body");
    BodyDef def = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    def.type = BodyType.StaticBody;
    FixtureDef sensorDef = new FixtureDef();
    sensorDef.isSensor = true;

    int coinID = 0;
    int starID = 0;
    float tileSize = layer.getTileHeight();

    GameTileRenderer.width = layer.getWidth();
    GameTileRenderer.height = layer.getHeight();
    GameTileRenderer.tlz = new int[GameTileRenderer.width][GameTileRenderer.height];
    for (int[] row : GameTileRenderer.tlz) Arrays.fill(row, -1);

    for (int row = 0; row < layer.getHeight(); row++) {
      for (int col = 0; col < layer.getWidth(); col++) {
        Cell cell = layer.getCell(col, row);
        if (cell == null || cell.getTile() == null) continue;

        // create

        def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);
        float x = col * tileSize / B2D.PPM;
        float y = row * tileSize / B2D.PPM;

        int tileType = cell.getTile().getId();
        tileType--;
        if (tileType <= 14) {
          // e element normal
          int id = tileType;

          GameTileRenderer.tlz[col][row] = id;
          ChainShape shape = new ChainShape();
          Vector2[] v = new Vector2[5];
          if (tileType < 14) {
            v[0] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            v[1] = new Vector2(-tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
            v[2] = new Vector2(tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
            v[3] = new Vector2(tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            v[4] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          } else {
            v[0] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            v[1] = new Vector2(-tileSize / 2 / B2D.PPM, 0 / B2D.PPM);
            v[2] = new Vector2(tileSize / 2 / B2D.PPM, 0 / B2D.PPM);
            v[3] = new Vector2(tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            v[4] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          }
          shape.createChain(v);
          fdef.friction = 0;
          fdef.shape = shape;
          if (tileType < 14) world.createBody(def).createFixture(fdef).setUserData("tile");
          else world.createBody(def).createFixture(fdef).setUserData("die");
        }

        if (tileType == 16) {
          // coin
          Cell c = new Cell();
          layer.setCell(col, row, c);
          if (GameStats.AddTheCoin(coinID)) {

            GameWorld.cr.coins.add(new Vector2(x, y));

            def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);

            ChainShape shape = new ChainShape();
            Vector2[] v = new Vector2[5];
            v[0] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            v[1] = new Vector2(-tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
            v[2] = new Vector2(tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
            v[3] = new Vector2(tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            v[4] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
            shape.createChain(v);

            sensorDef.shape = shape;

            TileData tmp = new TileData(coinID, "coin");
            coinID++;
            world.createBody(def).createFixture(sensorDef).setUserData(tmp);
          } else {
            GameWorld.cr.coins.add(null);
            coinID++;
          }
        }
        if (tileType == 17) {
          Cell c = new Cell();
          layer.setCell(col, row, c);
          GameWorld.cr.stars.add(new Vector2(x, y));

          def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);

          ChainShape shape = new ChainShape();
          Vector2[] v = new Vector2[5];
          v[0] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          v[1] = new Vector2(-tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
          v[2] = new Vector2(tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
          v[3] = new Vector2(tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          v[4] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          shape.createChain(v);

          sensorDef.shape = shape;

          TileData tmp = new TileData(starID, "star");
          starID++;
          world.createBody(def).createFixture(sensorDef).setUserData(tmp);
        }
        if (tileType == 18) {
          Cell c = new Cell();
          layer.setCell(col, row, c);
          GameMap.flagposition = new Vector2(x, y);
          def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);

          ChainShape shape = new ChainShape();
          Vector2[] v = new Vector2[5];
          v[0] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          v[1] = new Vector2(-tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
          v[2] = new Vector2(tileSize / 2 / B2D.PPM, tileSize / 2 / B2D.PPM);
          v[3] = new Vector2(tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          v[4] = new Vector2(-tileSize / 2 / B2D.PPM, -tileSize / 2 / B2D.PPM);
          shape.createChain(v);

          sensorDef.shape = shape;

          world.createBody(def).createFixture(sensorDef).setUserData("finish");
        }
        // tiles.add(new Vector2(x, y));

      }
    }
  }
  public void LoadGameTiles(TiledMap tileMap, World world) {
    TiledMapTileLayer layer = (TiledMapTileLayer) tileMap.getLayers().get("Tiles");
    BodyDef def = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    def.type = BodyType.StaticBody;
    FixtureDef sensorDef = new FixtureDef();
    sensorDef.isSensor = true;

    int coinID = 0;
    int starID = 0;
    float tileSize = layer.getTileHeight();

    GameTileRenderer.width = layer.getWidth();
    GameTileRenderer.height = layer.getHeight();
    GameTileRenderer.tlz = new int[GameTileRenderer.width][GameTileRenderer.height];
    for (int[] row : GameTileRenderer.tlz) Arrays.fill(row, -1);

    for (int row = 0; row < layer.getHeight(); row++) {
      for (int col = 0; col < layer.getWidth(); col++) {
        Cell cell = layer.getCell(col, row);
        if (cell == null || cell.getTile() == null) continue;

        // create

        def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);
        float x = col * tileSize / B2D.PPM;
        float y = row * tileSize / B2D.PPM;

        int tileType = cell.getTile().getId();
        tileType--;

        if (tileType == 11) {
          GameStats.GameSpawnPosition = new Vector2(x, y);
          Cell c = new Cell();
          layer.setCell(col, row, c);
        }
        if (tileType == 12) {
          Cell c = new Cell();
          layer.setCell(col, row, c);
          GameMap.flagposition = new Vector2(x, y);
          def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);
          sensorDef.shape = createShape(tileSize);
          world.createBody(def).createFixture(sensorDef).setUserData("finish");
        }
        if (tileType == 8) {
          // e spike
          int id = tileType;

          GameTileRenderer.tlz[col][row] = id;
          fdef.friction = 0;
          fdef.shape = createSpikeShape(tileSize);
          world.createBody(def).createFixture(fdef).setUserData("die");
        }
        if (tileType == 0 || tileType == 4) {
          // e element normal
          int id = tileType;

          GameTileRenderer.tlz[col][row] = id;
          fdef.friction = 0;
          fdef.shape = createShape(tileSize);
          world.createBody(def).createFixture(fdef).setUserData("tile");
        }
        if ((tileType >= 1 && tileType <= 3) || (tileType >= 5 && tileType <= 7)) {
          // e bara
          int id = tileType;

          GameTileRenderer.tlz[col][row] = id;
          fdef.friction = 0;
          fdef.shape = createShape(tileSize);
          world.createBody(def).createFixture(fdef).setUserData("rail");
        }
        if (tileType == 10) {
          // coin
          Cell c = new Cell();
          layer.setCell(col, row, c);
          if (GameStats.AddTheCoin(coinID)) {

            GameWorld.cr.coins.add(new Vector2(x, y));

            def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);

            sensorDef.shape = createShape(tileSize);

            TileData tmp = new TileData(coinID, "coin");
            coinID++;
            world.createBody(def).createFixture(sensorDef).setUserData(tmp);

          } else {
            GameWorld.cr.coins.add(null);
            coinID++;
          }
        }
        if (tileType == 9) {
          // coin

          Cell c = new Cell();
          layer.setCell(col, row, c);
          GameWorld.cr.stars.add(new Vector2(x, y));

          def.position.set((col + 0.5f) * tileSize / B2D.PPM, (row + 0.5f) * tileSize / B2D.PPM);

          sensorDef.shape = createShape(tileSize);

          TileData tmp = new TileData(starID, "star");
          starID++;
          world.createBody(def).createFixture(sensorDef).setUserData(tmp);
        }
      }
    }
  }
  public void Create() {
    // set tilemap file name
    m_MapFileName = "map/test.tmx";

    // set up the tilemap
    m_TiledMap = new TmxMapLoader().load(m_MapFileName);
    m_TiledMapRenderer = new OrthogonalTiledMapRenderer(m_TiledMap, 1f);

    // set up the box2d physics
    m_PhysicsWorld = new com.badlogic.gdx.physics.box2d.World(new Vector2(0, 0), true);

    // attach contact listener to physics world
    m_PhysicsWorld.setContactListener(new GameContactListener(this));

    // set up box2dlights
    m_RayHandler = new RayHandler(m_PhysicsWorld);
    m_RayHandler.setAmbientLight(0.0f);

    // add tilemap collision boxes to physics world
    for (int i = 0; i < m_TiledMap.getLayers().getCount(); i++) {
      if (m_TiledMap.getLayers().get(i) instanceof TiledMapTileLayer) {
        TiledMapTileLayer layer = (TiledMapTileLayer) m_TiledMap.getLayers().get(i);
        for (int j = 0; j < layer.getWidth(); j++) {
          for (int k = 0; k < layer.getHeight(); k++) {
            Cell cell = layer.getCell(j, k);
            if (cell != null) {
              TiledMapTile tile = cell.getTile();
              if (tile != null) {
                MapProperties props = tile.getProperties();
                if (props.containsKey("blocked")) {
                  float worldX = j * 64 + 32;
                  float worldY = k * 64 + 32;
                  BodyDef bodyDef = new BodyDef();
                  bodyDef.type = BodyType.StaticBody;
                  bodyDef.position.set(new Vector2(worldX * WORLD_TO_BOX, worldY * WORLD_TO_BOX));

                  Body newBody = m_PhysicsWorld.createBody(bodyDef);

                  PolygonShape boxShape = new PolygonShape();
                  boxShape.setAsBox(32 * WORLD_TO_BOX, 32 * WORLD_TO_BOX);

                  // Create a fixture definition to apply our shape to
                  FixtureDef fixtureDef = new FixtureDef();
                  fixtureDef.shape = boxShape;

                  newBody.createFixture(fixtureDef);

                  boxShape.dispose();
                }

                if (props.containsKey("rotate")) {
                  // flip some random tiles to break pattern
                  if (k * j % 3 == 0) layer.getCell(j, k).setFlipVertically(true);
                  if (k * j % 2 == 0) layer.getCell(j, k).setFlipHorizontally(true);
                }
              }
            }
          }
        }
      }
    }

    // set up artemis entity system
    m_ArtemisWorld = new com.artemis.World();

    // add the passive systems
    m_SpineRenderSystem = new SpineRenderSystem(m_GameScreen);
    m_ArtemisWorld.setSystem(m_SpineRenderSystem, true);

    // add the systems
    m_ArtemisWorld.setSystem(new PlayerInputSystem(this));
    m_ArtemisWorld.setSystem(new CameraSystem(m_GameScreen.m_Camera));
    m_ArtemisWorld.setSystem(new PhysicsSystem());
    m_ArtemisWorld.setSystem(new LifecycleSystem(this));
    m_ArtemisWorld.setSystem(new SteeringSystem());

    // init the world
    m_ArtemisWorld.initialize();
    EntityHelper.LoadObjects(
        m_GameScreen, m_ArtemisWorld, m_TiledMap, m_PhysicsWorld, m_RayHandler);

    // add player to entity list
    m_PlayerEntity = new PlayerEntity();
    m_PlayerEntity.AddToWorld(this);
    checkpointPos = new Vector2(0, 0);
    checkpointPos.x = m_PlayerEntity.m_Entity.getComponent(PositionComponent.class).m_X;
    checkpointPos.y = m_PlayerEntity.m_Entity.getComponent(PositionComponent.class).m_Y;

    // hud items are special cases since they needs to draw on top of border
    m_VialOne = new SpineComponent("map/vial", 5, 0.75f, -25);
    m_VialTwo = new SpineComponent("map/vial", 5, 0.65f, -5);
    m_VialThree = new SpineComponent("map/vial", 5, 0.75f, -50);
    m_WatchSpine = new SpineComponent("map/watch", 4, 0.75f, 0);

    if (m_GameScreen.m_Settings.m_WatchFound) {
      ActivateWatch();
      BodyComponent bodyComponent = m_PlayerEntity.m_Entity.getComponent(BodyComponent.class);
      bodyComponent.m_Body.setTransform(621 * WORLD_TO_BOX, 5961 * WORLD_TO_BOX, 0);
    }
    if (m_GameScreen.m_Settings.m_WeaponFound) {
      ActivateSword();
      BodyComponent bodyComponent = m_PlayerEntity.m_Entity.getComponent(BodyComponent.class);
      bodyComponent.m_Body.setTransform(1965 * WORLD_TO_BOX, 4842 * WORLD_TO_BOX, 0);
    }
    if (m_GameScreen.m_Settings.m_WeaponLightFound) {
      ActivateSwordLight();
      BodyComponent bodyComponent = m_PlayerEntity.m_Entity.getComponent(BodyComponent.class);
      bodyComponent.m_Body.setTransform(6390 * WORLD_TO_BOX, 6462 * WORLD_TO_BOX, 0);
    }
  }
  protected void loadTileLayer(TiledMap map, Element element) {
    if (element.getName().equals("layer")) {
      String name = element.getAttribute("name", null);
      int width = element.getIntAttribute("width", 0);
      int height = element.getIntAttribute("height", 0);
      int tileWidth = element.getParent().getIntAttribute("tilewidth", 0);
      int tileHeight = element.getParent().getIntAttribute("tileheight", 0);
      boolean visible = element.getIntAttribute("visible", 1) == 1;
      float opacity = element.getFloatAttribute("opacity", 1.0f);
      TiledMapTileLayer layer = new TiledMapTileLayer(width, height, tileWidth, tileHeight);
      layer.setVisible(visible);
      layer.setOpacity(opacity);
      layer.setName(name);

      TiledMapTileSets tilesets = map.getTileSets();

      Element data = element.getChildByName("data");
      String encoding = data.getAttribute("encoding", null);
      String compression = data.getAttribute("compression", null);
      if (encoding == null) { // no 'encoding' attribute means that the encoding is XML
        throw new GdxRuntimeException("Unsupported encoding (XML) for TMX Layer Data");
      }
      if (encoding.equals("csv")) {
        String[] array = data.getText().split(",");
        for (int y = 0; y < height; y++) {
          for (int x = 0; x < width; x++) {
            int id = (int) Long.parseLong(array[y * width + x].trim());

            final boolean flipHorizontally = ((id & FLAG_FLIP_HORIZONTALLY) != 0);
            final boolean flipVertically = ((id & FLAG_FLIP_VERTICALLY) != 0);
            final boolean flipDiagonally = ((id & FLAG_FLIP_DIAGONALLY) != 0);

            id = id & ~MASK_CLEAR;

            tilesets.getTile(id);
            TiledMapTile tile = tilesets.getTile(id);
            if (tile != null) {
              Cell cell = createTileLayerCell(flipHorizontally, flipVertically, flipDiagonally);
              cell.setTile(tile);
              layer.setCell(x, yUp ? height - 1 - y : y, cell);
            }
          }
        }
      } else {
        if (encoding.equals("base64")) {
          byte[] bytes = Base64Coder.decode(data.getText());
          if (compression == null) {
            int read = 0;
            for (int y = 0; y < height; y++) {
              for (int x = 0; x < width; x++) {

                int id =
                    unsignedByteToInt(bytes[read++])
                        | unsignedByteToInt(bytes[read++]) << 8
                        | unsignedByteToInt(bytes[read++]) << 16
                        | unsignedByteToInt(bytes[read++]) << 24;

                final boolean flipHorizontally = ((id & FLAG_FLIP_HORIZONTALLY) != 0);
                final boolean flipVertically = ((id & FLAG_FLIP_VERTICALLY) != 0);
                final boolean flipDiagonally = ((id & FLAG_FLIP_DIAGONALLY) != 0);

                id = id & ~MASK_CLEAR;

                tilesets.getTile(id);
                TiledMapTile tile = tilesets.getTile(id);
                if (tile != null) {
                  Cell cell = createTileLayerCell(flipHorizontally, flipVertically, flipDiagonally);
                  cell.setTile(tile);
                  layer.setCell(x, yUp ? height - 1 - y : y, cell);
                }
              }
            }
          } else if (compression.equals("gzip")) {
            throw new GdxRuntimeException("GZIP compression not supported in GWT backend");
          } else if (compression.equals("zlib")) {
            throw new GdxRuntimeException("ZLIB compression not supported in GWT backend");
          }
        } else {
          // any other value of 'encoding' is one we're not aware of, probably a feature of a future
          // version of Tiled
          // or another editor
          throw new GdxRuntimeException(
              "Unrecognised encoding (" + encoding + ") for TMX Layer Data");
        }
      }
      Element properties = element.getChildByName("properties");
      if (properties != null) {
        loadProperties(layer.getProperties(), properties);
      }
      map.getLayers().add(layer);
    }
  }
 public TiledMapTile getTile(float x, float y) {
   Vector2 tileIndex = getTileIndex(x, y);
   Cell cell = decorativeLayer.getCell((int) tileIndex.x, (int) tileIndex.y);
   return cell.getTile();
 }
Beispiel #13
0
  private void loadLayer(TiledMap map, Element element) {
    if (element.getName().equals("Layer")) {
      String id = element.getAttribute("Id");
      String visible = element.getAttribute("Visible");

      Element dimensions = element.getChildByName("Dimensions");
      String layerSize = dimensions.getAttribute("LayerSize");
      String tileSize = dimensions.getAttribute("TileSize");

      String[] layerSizeParts = layerSize.split(" x ");
      int layerSizeX = Integer.parseInt(layerSizeParts[0]);
      int layerSizeY = Integer.parseInt(layerSizeParts[1]);

      String[] tileSizeParts = tileSize.split(" x ");
      int tileSizeX = Integer.parseInt(tileSizeParts[0]);
      int tileSizeY = Integer.parseInt(tileSizeParts[1]);

      TiledMapTileLayer layer = new TiledMapTileLayer(layerSizeX, layerSizeY, tileSizeX, tileSizeY);
      Element tileArray = element.getChildByName("TileArray");
      Array<Element> rows = tileArray.getChildrenByName("Row");
      TiledMapTileSets tilesets = map.getTileSets();
      TiledMapTileSet currentTileSet = null;
      int firstgid = 0;
      int x, y;
      for (int row = 0, rowCount = rows.size; row < rowCount; row++) {
        Element currentRow = rows.get(row);
        y = rowCount - 1 - row;
        x = 0;
        for (int child = 0, childCount = currentRow.getChildCount(); child < childCount; child++) {
          Element currentChild = currentRow.getChild(child);
          String name = currentChild.getName();
          if (name.equals("TileSheet")) {
            currentTileSet = tilesets.getTileSet(currentChild.getAttribute("Ref"));
            firstgid = currentTileSet.getProperties().get("firstgid", Integer.class);
          } else if (name.equals("Null")) {
            x += currentChild.getIntAttribute("Count");
          } else if (name.equals("Static")) {
            Cell cell = new Cell();
            cell.setTile(currentTileSet.getTile(firstgid + currentChild.getIntAttribute("Index")));
            layer.setCell(x++, y, cell);
          } else if (name.equals("Animated")) {
            // Create an AnimatedTile
            int interval = currentChild.getInt("Interval");
            Element frames = currentChild.getChildByName("Frames");
            Array<StaticTiledMapTile> frameTiles = new Array<StaticTiledMapTile>();
            for (int frameChild = 0, frameChildCount = frames.getChildCount();
                frameChild < frameChildCount;
                frameChild++) {
              Element frame = frames.getChild(frameChild);
              String frameName = frame.getName();
              if (frameName.equals("TileSheet")) {
                currentTileSet = tilesets.getTileSet(frame.getAttribute("Ref"));
                firstgid = currentTileSet.getProperties().get("firstgid", Integer.class);
              } else if (frameName.equals("Static")) {
                frameTiles.add(
                    (StaticTiledMapTile)
                        currentTileSet.getTile(firstgid + frame.getIntAttribute("Index")));
              }
            }
            Cell cell = new Cell();
            cell.setTile(new AnimatedTiledMapTile(interval / 1000f, frameTiles));
            layer.setCell(x++, y, cell); // TODO: Reuse existing animated tiles
          }
        }
      }
      map.getLayers().add(layer);
    }
  }