public void LoadNewMethod(World world) {
    // load boxr

    Parameters params = new Parameters();
    params.textureMinFilter = TextureFilter.Linear;
    params.textureMagFilter = TextureFilter.Linear;

    TiledMap tileMap = new TmxMapLoader().load("Maps/level" + GameStats.Level + ".tmx");

    for (TiledMapTileSet tileSet : tileMap.getTileSets()) {
      Iterator<TiledMapTile> it = tileSet.iterator();
      while (it.hasNext()) {

        it.next()
            .getTextureRegion()
            .getTexture()
            .setFilter(TextureFilter.Linear, TextureFilter.Linear);
      }
    }
    // LoadTilesWithBody(tileMap, world);
    // LoadTilesWithoutBody(tileMap, world);
    LoadGameTiles(tileMap, world);
    renderer = new OrthogonalTiledMapRenderer(tileMap, 1 / 100f);

    // tileMap.dispose();

  }
Exemple #2
0
  Tilemap() {
    tiledMap = new TmxMapLoader().load("temp.tmx");
    mapLayer = (TiledMapTileLayer) tiledMap.getLayers().get(0);
    tiledMapRenderer = new OrthogonalTiledMapRenderer(tiledMap);

    blockTile = new TmxMapLoader().load("block.tmx");
    blockLayer = (TiledMapTileLayer) blockTile.getLayers().get(0);
  }
Exemple #3
0
 public Vector2 getTriggerPoint(String name) {
   final MapObject triggerObject = tiledMap.getLayers().get("trigger").getObjects().get(name);
   if (triggerObject == null) {
     return null;
   }
   final int tileWidth = (Integer) tiledMap.getProperties().get("tilewidth");
   final int tileHeight = (Integer) tiledMap.getProperties().get("tileheight");
   return new Vector2(
       (Float) triggerObject.getProperties().get("x") / tileWidth,
       (Float) triggerObject.getProperties().get("y") / tileHeight);
 }
  public static void convertMap(
      World box2dWorld,
      TiledMap map,
      float PPM,
      float playfieldOffsetX,
      float playfieldOffsetY,
      int defaultID) {

    TiledMapTileLayer layer = (TiledMapTileLayer) map.getLayers().get(0);

    for (int y = 0; y <= layer.getHeight() - 1; y++) {
      for (int x = 0; x <= layer.getWidth() - 1; x++) {
        Cell cell = layer.getCell(x, y);
        if (cell != null) {

          PhysicsBodyFactory.addStaticTileBodyAndFixture(
              defaultID,
              box2dWorld,
              playfieldOffsetX + ((x + 1) * layer.getTileWidth() / PPM),
              playfieldOffsetY + ((y + 1) * layer.getTileHeight() / PPM),
              layer.getTileWidth() / PPM,
              layer.getTileHeight() / PPM,
              0,
              0);
        }
      }
    }
  }
Exemple #5
0
  /**
   * Randomly selects and returns a set of predefined obstacles from the map.
   *
   * @return the map layer containing the obstacles
   */
  private TiledMapTileLayer chooseObstacles() {
    int count = 0;

    // First count how many obstacle layers we have.
    while (map.getLayers().get(String.format("Obstacles%d", count)) != null) {
      count++;
    }

    // Choose a random layer or return null if there are no layers.
    if (count == 0) {
      return null;
    } else {
      return (TiledMapTileLayer)
          map.getLayers().get(String.format("Obstacles%d", MathUtils.random(0, count - 1)));
    }
  }
  private void createCoins() {
    coins = new Array<Coin>();

    MapLayer layer = tileMap.getLayers().get("Coins");
    BodyDef bdef = new BodyDef();
    FixtureDef fdef = new FixtureDef();
    for (MapObject mo : layer.getObjects()) {
      bdef.type = BodyType.StaticBody;
      float x = mo.getProperties().get("x", Float.class) / PPM;
      float y = mo.getProperties().get("y", Float.class) / PPM;

      bdef.position.set(x, y);
      CircleShape cShape = new CircleShape();
      cShape.setRadius(8 / PPM);
      fdef.shape = cShape;
      fdef.isSensor = true;
      fdef.filter.categoryBits = B2DVars.BIT_COINS;
      fdef.filter.maskBits = B2DVars.BIT_PLAYER;
      Body body = world.createBody(bdef);
      body.createFixture(fdef).setUserData("coin");
      Coin c = new Coin(body);
      coins.add(c);

      body.setUserData(c);
    }
  }
  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;
        }
      }
    }
  }
Exemple #8
0
  public void applyPhysics(World world) {
    final Iterator<MapLayer> layerIterator = tiledMap.getLayers().iterator();
    while (layerIterator.hasNext()) {
      final MapLayer mapLayer = layerIterator.next();
      if (mapLayer instanceof TiledMapTileLayer) {
        final TiledMapTileLayer tiledLayer = (TiledMapTileLayer) mapLayer;
        final int width = tiledLayer.getWidth();
        final int height = tiledLayer.getHeight();
        for (int y = 0; y < height; y++) {
          for (int x = 0; x < width; x++) {
            final TiledMapTileLayer.Cell cell = tiledLayer.getCell(x, y);
            if (cell == null) {
              continue;
            }
            final boolean dirt = cell.getTile().getProperties().containsKey("dirt");
            final boolean noWall = cell.getTile().getProperties().containsKey("nowall");
            if (!noWall) {
              addBody(world, x + offset.x, y + offset.y, dirt);
            }
          }
        }
      }
    }

    for (String portalName : portals.keySet()) {
      final Vector2 portalPosition = portals.get(portalName);
      addPortalBody(world, portalName, portalPosition);
    }

    final Vector2 finish = getTriggerPoint("finish");
    if (finish != null) {
      addFinish(world, finish);
    }
  }
Exemple #9
0
 @Override
 public void dispose() {
   batch.dispose();
   ui.dispose();
   fontLabel.dispose();
   stage.dispose();
   skin.dispose();
   tiledMap.dispose();
 }
  public void getCollidingRects() {
    MapObjects objects = tiledMap.getLayers().get("phyics").getObjects();
    collideRects = new Array<Rectangle>();

    for (MapObject object : objects) {
      RectangleMapObject rectangleObject = (RectangleMapObject) object;
      collideRects.add(rectangleObject.getRectangle());
    }
  }
Exemple #11
0
  Map(MapFactory.MapType mapType, String fullMapPath) {
    json = new Json();
    mapEntities = new Array<Entity>(10);
    currentMapType = mapType;
    playerStart = new Vector2(0, 0);
    playerStartPositionRect = new Vector2(0, 0);
    closestPlayerStartPosition = new Vector2(0, 0);
    convertedUnits = new Vector2(0, 0);

    if (fullMapPath == null || fullMapPath.isEmpty()) {
      Gdx.app.debug(TAG, "Map is invalid");
      return;
    }

    Utility.loadMapAsset(fullMapPath);
    if (Utility.isAssetLoaded(fullMapPath)) {
      currentMap = Utility.getMapAsset(fullMapPath);
    } else {
      Gdx.app.debug(TAG, "Map not loaded");
      return;
    }

    collisionLayer = currentMap.getLayers().get(COLLISION_LAYER);
    if (collisionLayer == null) {
      Gdx.app.debug(TAG, "No collision layer!");
    }

    portalLayer = currentMap.getLayers().get(PORTAL_LAYER);
    if (portalLayer == null) {
      Gdx.app.debug(TAG, "No portal layer!");
    }

    spawnsLayer = currentMap.getLayers().get(SPAWNS_LAYER);
    if (spawnsLayer == null) {
      Gdx.app.debug(TAG, "No spawn layer!");
    } else {
      setClosestStartPosition(playerStart);
    }

    npcStartPositions = getNPCStartPositions();
    specialNPCStartPositions = getSpecialNPCStartPositions();
  }
Exemple #12
0
 public Map<String, Vector2> getTriggerStartWith(String name) {
   final HashMap<String, Vector2> triggerObjects = new HashMap<String, Vector2>();
   final Iterator<MapObject> mapObjectIterator =
       tiledMap.getLayers().get("trigger").getObjects().iterator();
   final int tileWidth = (Integer) tiledMap.getProperties().get("tilewidth");
   final int tileHeight = (Integer) tiledMap.getProperties().get("tileheight");
   while (mapObjectIterator.hasNext()) {
     final MapObject mapObject = mapObjectIterator.next();
     if (mapObject != null
         && mapObject.getName() != null
         && mapObject.getName().startsWith(name)) {
       triggerObjects.put(
           mapObject.getName(),
           new Vector2(
               (Float) mapObject.getProperties().get("x") / tileWidth,
               (Float) mapObject.getProperties().get("y") / tileHeight));
     }
   }
   return triggerObjects;
 }
  public LevelRenderer(
      final TiledMap map, final AssetManager assets, final Batch batch, final float unitScale) {
    collectibles = new Array<CollectibleRenderer>(3);

    Texture background =
        assets.get(
            map.getProperties()
                .get(BACKGROUND_PROPERTY, Assets.DEFAULT_BACKGROUND.fileName, String.class),
            Texture.class);

    renderer = new BackgroundTiledMapRenderer(map, unitScale, batch, background);
  }
Exemple #14
0
  @Override
  public void create() {
    batch = new SpriteBatch();
    world = new World(new Vector2(0, -9.8f), true);
    ninjaRabbit = EntityFactory.createNinjaRabbit(world);

    InputProcessor inputProcessor =
        new InputMultiplexer(
            new NinjaRabbitInputProcessor(ninjaRabbit),
            new InputAdapter() {
              @Override
              public boolean scrolled(final int amount) {
                viewport.setUnitsPerPixel(
                    viewport.getUnitsPerPixel() + viewport.getUnitsPerPixel() / amount / 8f);
                viewport.update(viewport.getScreenWidth(), viewport.getScreenHeight());
                return true;
              }
            });

    Gdx.input.setInputProcessor(inputProcessor);

    TiledMap tileMap = new TmxMapLoader().load(LEVEL_MAP_FILE);
    Box2DMapObjectParser objectParser = new Box2DMapObjectParser(1 / PPM);
    objectParser.load(world, tileMap);
    tileMapRenderer = new OrthogonalTiledMapRenderer(tileMap, 1 / PPM);

    viewport = new ScreenViewport();
    viewport.setUnitsPerPixel(1 / PPM);
    viewport.setCamera(
        new BoundedCamera(
            0.0f,
            tileMap.getProperties().get("width", Integer.class).floatValue()
                * tileMap.getProperties().get("tilewidth", Integer.class).floatValue()
                / PPM));

    b2dRenderer = new Box2DDebugRenderer();
  }
 @Override
 public void render(int[] layers) {
   beginRender();
   for (int layerIdx : layers) {
     MapLayer layer = map.getLayers().get(layerIdx);
     if (layer.isVisible()) {
       if (layer instanceof TiledMapTileLayer) {
         renderTileLayer((TiledMapTileLayer) layer);
       } else {
         for (MapObject object : layer.getObjects()) {
           renderObject(object);
         }
       }
     }
   }
   endRender();
 }
 @Override
 public void render() {
   AnimatedTiledMapTile.updateAnimationBaseTime();
   spriteBatch.begin();
   for (MapLayer layer : map.getLayers()) {
     if (layer.isVisible()) {
       if (layer instanceof TiledMapTileLayer) {
         renderTileLayer((TiledMapTileLayer) layer);
       } else {
         for (MapObject object : layer.getObjects()) {
           renderObject(object);
         }
       }
     }
   }
   spriteBatch.end();
 }
Exemple #17
0
  private void loadCollisionBoxes() {
    MapLayer collisionLayer = map.getLayers().get("collisions");

    Game.debug("Inflating Collision Rectangles / Tile Data");

    for (RectangleMapObject object :
        collisionLayer.getObjects().getByType(RectangleMapObject.class)) {
      if (object.getProperties().containsKey("spawnpoint")) {
        spawnpoint = new Vector2(object.getRectangle().x, object.getRectangle().y);
        Game.debug("Set Spawn Point to: " + spawnpoint.toString());
      }
      if (!object.getProperties().containsKey("collision")) continue;
      Game.debug("Added Collision Rectangle at: " + object.getRectangle().toString());
      collisions.add(object.getRectangle());
    }
    Game.debug("Added " + collisions.size() + " Collision Rectangles");
  }
 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);
     }
   }
 }
Exemple #19
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;
      }
    }
  }
Exemple #20
0
  public void init() {
    //        camera = new OrthographicCamera();
    //        viewport = new FitViewport(SCENE_WIDTH, SCENE_HEIGHT, camera);

    float w = Gdx.graphics.getWidth();
    float h = Gdx.graphics.getHeight();

    camera = new OrthographicCamera();
    viewport = new FitViewport(SCENE_WIDTH, SCENE_HEIGHT, camera); // 設置鏡頭大小
    camera.setToOrtho(false, w, h); // y軸向上
    camera.update();

    batch = new SpriteBatch();
    deltaTime = 0.0f;
    xPosition = 0;

    // Load atlases and textures
    //        hero1Atlas = new TextureAtlas(Gdx.files.internal("hero/shana/RunningRight.pack"));
    hero1Atlas = new TextureAtlas(Gdx.files.internal("hero/shana/heroShana.pack"));

    TextureRegion[] frameWalkingRight = new TextureRegion[8];
    frameWalkingRight[0] = hero1Atlas.findRegion("RunningRight1");
    frameWalkingRight[1] = hero1Atlas.findRegion("RunningRight2");
    frameWalkingRight[2] = hero1Atlas.findRegion("RunningRight3");
    frameWalkingRight[3] = hero1Atlas.findRegion("RunningRight4");
    frameWalkingRight[4] = hero1Atlas.findRegion("RunningRight5");
    frameWalkingRight[5] = hero1Atlas.findRegion("RunningRight6");
    frameWalkingRight[6] = hero1Atlas.findRegion("RunningRight7");
    frameWalkingRight[7] = hero1Atlas.findRegion("RunningRight8");

    // Load animations
    //        animation = new Animation(FRAME_DURATION, hero1Atlas.getRegions(),
    // Animation.PlayMode.LOOP);
    animation = new Animation(FRAME_DURATION, frameWalkingRight);

    HUDBatch = new SpriteBatch();
    font1 = new BitmapFont();
    font1.setColor(Color.YELLOW);

    tiledMap = new TmxMapLoader().load("map/newmap2.tmx");

    tiledMapRenderer = new OrthogonalTiledMapRenderer(tiledMap);
    foregroundLayer = (TiledMapTileLayer) tiledMap.getLayers().get("foreground");
  }
  private void updateCamera() {
    direction.set(0.0f, 0.0f);
    int mouseX = Gdx.input.getX();
    int mouseY = Gdx.input.getY();
    int width = Gdx.graphics.getWidth();
    int height = Gdx.graphics.getHeight();

    if (Gdx.input.isKeyPressed(Input.Keys.LEFT)
        || (Gdx.input.isTouched() && mouseX < width * 0.75f)) {
      direction.x = -1;
    } else if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)
        || (Gdx.input.isTouched() && mouseX > width * 0.75f)) {
      direction.x = 1;
    }

    if (Gdx.input.isKeyPressed(Input.Keys.UP)
        || (Gdx.input.isTouched() && mouseY < height * 0.75f)) {
      direction.y = 1;
    } else if (Gdx.input.isKeyPressed(Input.Keys.DOWN)
        || (Gdx.input.isTouched() && mouseY > height * 0.75f)) {
      direction.y = -1;
    }

    direction.nor().scl(CAMERA_SPEED * Gdx.graphics.getDeltaTime());

    camera.position.x += direction.x;
    camera.position.y += direction.y;

    TiledMapTileLayer layer = (TiledMapTileLayer) tiledMap.getLayers().get(0);

    float cameraMinX = viewport.getWorldWidth() * 0.5f;
    float cameraMinY = viewport.getWorldHeight() * 0.5f;
    float cameraMaxX = layer.getWidth() * layer.getTileWidth() + (playerWidth - cameraMinX);
    float cameraMaxY = layer.getHeight() * layer.getTileHeight() - cameraMinY;

    camera.position.x = MathUtils.clamp(sprite.getX(), cameraMinX, cameraMaxX);
    camera.position.y = MathUtils.clamp(sprite.getY(), cameraMinY, cameraMaxY);

    camera.update();
  }
 @Override
 public void render(GamePlayManager main) {
   boolean drewBG = false;
   boolean drewPlayer = false;
   beginRender();
   for (MapLayer layer : map.getLayers()) {
     if (!layer.getName().equals("AINODEMAP")) {
       if (!drewBG && layer.getProperties().containsKey("bg")) {
         drewBG = true;
         main.drawBackGround(spriteBatch);
       }
       if (!drewPlayer && layer.getProperties().containsKey("player")) {
         main.drawPlayerLayer(spriteBatch);
         drewPlayer = true;
       }
       if (layer.isVisible()) {
         renderTileLayer((TiledMapTileLayer) layer);
       }
     }
   }
   endRender();
 }
 private boolean _loadLayersRoutine(TiledMap map) throws STiledLevelException {
   tile_width = map.getProperties().get("tilewidth", Integer.class);
   tile_height = map.getProperties().get("tileheight", Integer.class);
   map_width = map.getProperties().get("width", Integer.class);
   map_height = map.getProperties().get("height", Integer.class);
   decorativeLayer = (TiledMapTileLayer) map.getLayers().get("DecorativeLayer");
   if (decorativeLayer == null) {
     throw new STiledLevelException(
         "Missing DecorativeLayer. Add DecorativeLayer to your tiled map");
   }
   metaLayer = (TiledMapTileLayer) map.getLayers().get("MetaLayer");
   if (metaLayer == null) {
     throw new STiledLevelException("Missing MetaLayer. Add MetaLayer to your tiled map");
   }
   objectLayer = map.getLayers().get("ObjectLayer");
   if (objectLayer == null) {
     throw new STiledLevelException("Missing ObjectLayer. Add ObjectLayer to your tiled map");
   }
   return true;
 }
Exemple #24
0
 public void draw(Batch batch) {
   batch.begin();
   final Iterator<MapLayer> layerIterator = tiledMap.getLayers().iterator();
   while (layerIterator.hasNext()) {
     final MapLayer mapLayer = layerIterator.next();
     if (mapLayer instanceof TiledMapTileLayer) {
       final TiledMapTileLayer tiledLayer = (TiledMapTileLayer) mapLayer;
       final int width = tiledLayer.getWidth();
       final int height = tiledLayer.getHeight();
       for (int y = 0; y < height; y++) {
         for (int x = 0; x < width; x++) {
           final TiledMapTileLayer.Cell cell = tiledLayer.getCell(x, y);
           if (cell == null) {
             continue;
           }
           final TextureRegion textureRegion = cell.getTile().getTextureRegion();
           batch.draw(textureRegion, x + offset.x, y + offset.y, 1, 1);
         }
       }
     }
   }
   batch.end();
 }
  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);
      }
    }
  }
 public TiledMapTileLayer.Cell getCell() {
   TiledMapTileLayer layer = (TiledMapTileLayer) map.getLayers().get(2);
   return layer.getCell(
       (int) (body.getPosition().x * StarWars.PPM / 16),
       (int) (body.getPosition().y * StarWars.PPM / 16));
 }
  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 load(World world, TiledMap map) throws Exception {

    // Set platform box2D data
    if (map.getLayers().get("Platform") != null
        && map.getLayers().get("Platform").getObjects().getCount() != 0) {
      map.getLayers().get("Platform").getProperties().put("type", Constants.BOX2D_OBJECT);
      map.getLayers()
          .get("Platform")
          .getProperties()
          .put("categoryBits", Constants.PLATFORM_CATEGORY);
      map.getLayers().get("Platform").getProperties().put("maskBits", Constants.PLATFORM_MASK);
      map.getLayers()
          .get("Platform")
          .getProperties()
          .put("userData", Constants.BOX2D_PLATFORM_USERDATA);
    } else {
      throw new Exception(
          "Error: Map have no platforms (The object layer of platforms has to be named as 'Platform')");
    }

    // Set spikes' box2D data
    if (map.getLayers().get("Spike") != null
        && map.getLayers().get("Spike").getObjects().getCount() != 0) {
      map.getLayers().get("Spike").getProperties().put("type", Constants.BOX2D_OBJECT);
      map.getLayers().get("Spike").getProperties().put("categoryBits", Constants.PLATFORM_CATEGORY);
      map.getLayers().get("Spike").getProperties().put("userData", Constants.BOX2D_SPIKE_USERDATA);
      map.getLayers().get("Spike").getProperties().put("maskBits", Constants.SPIKE_MASK);
    }

    // Set moving platform's box2D data
    if (map.getLayers().get("MovingPlatform") != null
        && map.getLayers().get("MovingPlatform").getObjects().getCount() != 0) {
      int i = 0;
      for (MapObject mo : map.getLayers().get("MovingPlatform").getObjects()) {
        mo.setName("mplatform" + i);
        mo.getProperties().put("type", Constants.BOX2D_OBJECT);
        mo.getProperties().put("bodyType", Constants.BOX2D_KINEMATIC_BODY_TYPE);
        mo.getProperties().put("userData", Constants.BOX2D_PLATFORM_USERDATA);
        mo.getProperties().put("categoryBits", Constants.PLATFORM_CATEGORY);
        mo.getProperties().put("maskBits", Constants.PLATFORM_MASK);
        i++;
      }
    }

    // Check if spawnpoint exists
    if (map.getLayers().get("Points") == null
        || map.getLayers().get("Points").getObjects().get("Spawnpoint") == null) {
      throw new Exception(
          "Error: Map have no spawnpoint (Check that you have object layer called Points and element called 'Spawnpoint')");
    }

    // Check if goal exists in map and set box2D data
    if (map.getLayers().get("Points").getObjects().get("Goal") != null) {
      map.getLayers()
          .get("Points")
          .getObjects()
          .get("Goal")
          .getProperties()
          .put("type", Constants.BOX2D_OBJECT);
      map.getLayers()
          .get("Points")
          .getObjects()
          .get("Goal")
          .getProperties()
          .put("categoryBits", Constants.GOAL_CATEGORY);
      map.getLayers()
          .get("Points")
          .getObjects()
          .get("Goal")
          .getProperties()
          .put("userData", Constants.BOX2D_GOAL_USERDATA);
      map.getLayers().get("Points").getProperties().put("maskBits", Constants.GOAL_MASK);
    } else {
      throw new Exception(
          "Error: Map have no goal (Check that you have object layer called Points and element called 'Goal')");
    }

    super.load(world, map);
  }
Exemple #30
0
 public void loadGameMap() {
   tiledMap = new TmxMapLoader().load("maps/testMap.tmx");
   renderer = new OrthogonalTiledMapRenderer(tiledMap, unitScale);
   wallLayer = (TiledMapTileLayer) tiledMap.getLayers().get("Walls");
 }