Java 如何使.tmx映射填充整个屏幕

我正在使用Libgdx加载一个.tmx映射，而映射并没有填满整个屏幕。我无法解决这个问题，所以作为最后的手段，我在这里问一个问题。我在YouTube上关注一个教程，他没有涵盖这个问题，因此我无法继续。我尝试了很多事情，但都没有成功。地图的宽度为240块，高度为13块，16乘16

,，

这是代码。我认为这个问题与

renderer = new OrthogonalTiledMapRenderer(map, 1/DBZ.PPM),
gameCam.position.set(gamePort.getWorldWidth()/2, 
gamePort.getWorldHeight()/2, 0);,
gameCam = new OrthographicCamera(); 
gamePort = new FitViewport(DBZ.V_WIDTH/DBZ.PPM, DBZ.V_HEIGHT/DBZ.PPM, gameCam);

    public class PlayScreen implements Screen {
    private  DBZ game;
    private OrthographicCamera gameCam;
    private Viewport gamePort;
    private Hud hud;
    private TmxMapLoader maploader;
    private TiledMap map;
    private OrthogonalTiledMapRenderer renderer;

    private World world;
    private Box2DDebugRenderer b2dr;

    private Goku player;
    private TextureAtlas atlas;


    public PlayScreen(DBZ game){
        atlas = new TextureAtlas("goku.pack");
        this.game=  game;
        gameCam = new OrthographicCamera();
        gamePort = new FitViewport(DBZ.V_WIDTH/DBZ.PPM, DBZ.V_HEIGHT/DBZ.PPM, gameCam);
        hud = new Hud(game.batch);
        maploader= new TmxMapLoader();
        map = maploader.load("level1.tmx");
        renderer = new OrthogonalTiledMapRenderer(map, 1/DBZ.PPM);
        gameCam.position.set(gamePort.getWorldWidth()/2, gamePort.getWorldHeight()/2, 0);
        world = new World(new Vector2(0,-10),true);
        b2dr = new Box2DDebugRenderer();
        new B2WorldCreator(world,map);
        player = new Goku(world, this);
    }

    public TextureAtlas getAtlas(){
        return atlas;
    }

    @Override
    public void show() {

    }

    public void handleInput(float dt){
        if (Gdx.input.isKeyJustPressed(Input.Keys.UP))
            player.b2body.applyLinearImpulse(new Vector2(0, 4f), player.b2body.getWorldCenter(), true);
        if (Gdx.input.isKeyPressed(Input.Keys.RIGHT) && player.b2body.getLinearVelocity().x <= 2)
            player.b2body.applyLinearImpulse(new Vector2(0.1f, 0), player.b2body.getWorldCenter(), true);
        if (Gdx.input.isKeyPressed(Input.Keys.LEFT) && player.b2body.getLinearVelocity().x >= -2)
            player.b2body.applyLinearImpulse(new Vector2(-0.1f, 0), player.b2body.getWorldCenter(), true);

    }

    public void update(float dt){
        handleInput(dt);

        world.step(1/60f, 6, 2);
        player.update(dt);
        gameCam.position.x = player.b2body.getPosition().x;





        gameCam.update();
        renderer.setView(gameCam);

    }

    @Override
    public void render(float delta) {
        update(delta);
        Gdx.gl.glClearColor(0, 0, 0, 0);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        renderer.render();

        b2dr.render(world, gameCam.combined);

        game.batch.setProjectionMatrix(gameCam.combined);
        game.batch.begin();
        player.draw(game.batch);
        game.batch.end();

        game.batch.setProjectionMatrix(hud.stage.getCamera().combined);
        hud.stage.draw();

    }

    @Override
    public void resize(int width, int height) {
        gamePort.update(width, height);


    }

    @Override
    public void pause() {

    }

    @Override
    public void resume() {

    }

    @Override
    public void hide() {

    }

    @Override
    public void dispose() {
        map.dispose();
        renderer.dispose();
        world.dispose();
        b2dr.dispose();
        hud.dispose();

    }
}

public class DBZ extends Game{
    public SpriteBatch batch;
    public  static final int V_WIDTH = 400;
    public  static final int V_HEIGHT = 208;
    public static final float PPM = 100;


    @Override
    public void create () {
        batch = new SpriteBatch();
        setScreen(new PlayScreen(this));
    }

    @Override
    public void render () {
        super.render();
    }

    @Override
    public void dispose () {
        batch.dispose();
    }
}

public class Goku extends Sprite {
    public World world;
    public Body b2body;
    private TextureRegion gokuStand;

    public Goku(World world, PlayScreen screen){
        super(screen.getAtlas().findRegion("goku_sprite"));
        this.world = world;
        defineGoku();
        gokuStand = new TextureRegion(getTexture(), 5,12,59,85);
        setBounds(0,0,59/DBZ.PPM,85/DBZ.PPM);
        setRegion(gokuStand);

    }

    public void defineGoku(){
        BodyDef bdef = new BodyDef();
        bdef.position.set(32/DBZ.PPM,32/DBZ.PPM);
        bdef.type = BodyDef.BodyType.DynamicBody;
        b2body = world.createBody(bdef);

        FixtureDef fdef = new FixtureDef();
        PolygonShape shape = new PolygonShape();
        shape.setAsBox(59/2/DBZ.PPM, 85/2/DBZ.PPM);

        fdef.shape = shape;
        b2body.createFixture(fdef);

    }

    public void update(float dt){
        setPosition(b2body.getPosition().x - getWidth()/2, b2body.getPosition().y - getHeight()/2 );

    }

}

renderer=新的正交平铺贴图渲染器（贴图，1/DBZ.PPM），
gameCam.position.set（gamePort.getWorldWidth（）/2，
gamePort.getWorldHeight（）/2，0）；，
gameCam=新的正交摄影机（）；
gamePort=新的FitViewport（DBZ.V_宽度/DBZ.PPM，DBZ.V_高度/DBZ.PPM，gameCam）；
公共类PlayScreen实现屏幕{
私人DBZ游戏；
私人正交摄影机；
专用视口游戏端口；
私人抬头显示器；
专用TmxMapLoader映射加载器；
私人平铺地图；
私有正交瓦片渲染器；
私人世界；
私人邮箱2DDR；
私人小悟空玩家；
私人地图集；
公共播放屏幕（DBZ游戏）{
atlas=新的TextureAtlas（“悟空包”）；
这个。游戏=游戏；
gameCam=新的正交摄影机（）；
gamePort=新的FitViewport（DBZ.V_宽度/DBZ.PPM，DBZ.V_高度/DBZ.PPM，gameCam）；
hud=新hud（游戏批处理）；
maploader=新的TmxMapLoader（）；
map=maploader.load（“level1.tmx”）；
渲染器=新的正交平铺贴图渲染器（贴图，1/DBZ.PPM）；
gameCam.position.set（gamePort.getWorldWidth（）/2，gamePort.getWorldHeight（）/2，0）；
世界=新世界（新矢量2（0，-10），真）；
b2dr=新的Box2DebugRenderer（）；
新的B2WorldCreator（世界，地图）；
玩家=新小悟空（世界，这个）；
}
公共纹理图集（）{
返回地图集；
}
@凌驾
公开展览（{
}
公共无效手动输入（浮动dt）{
if（Gdx.input.isKeyJustPressed（input.Keys.UP））
player.b2body.applylinearpulse（新向量2（0，4f），player.b2body.getWorldCenter（），true）；
if（Gdx.input.isKeyPressed（input.Keys.RIGHT）和&player.b2body.getLinearVelocity（）.x=-2）
player.b2body.applylinearpulse（新向量2（-0.1f，0），player.b2body.getWorldCenter（），true）；
}
公共无效更新（浮动dt）{
handleInput（dt）；
世界.步骤（1/60f、6、2）；
player.update（dt）；
gameCam.position.x=player.b2body.getPosition（）.x；
gameCam.update（）；
渲染器.setView（gameCam）；
}
@凌驾
公共无效渲染（浮动增量）{
更新（增量）；
glClearColor（0,0,0,0）；
Gdx.gl.glClear（GL20.gl\u颜色\u缓冲\u位）；
render.render（）；
b2dr.render（世界、游戏摄影机、组合）；
game.batch.setProjectionMatrix（gameCam.combined）；
game.batch.begin（）；
玩家。抽签（游戏。批量）；
game.batch.end（）；
game.batch.setProjectionMatrix（hud.stage.getCamera（）.combined）；
hud.stage.draw（）；
}
@凌驾
公共空心调整大小（整型宽度、整型高度）{
游戏端口。更新（宽度、高度）；
}
@凌驾
公共空间暂停（）{
}
@凌驾
公众简历（）{
}
@凌驾
公共空间隐藏（）{
}
@凌驾
公共空间处置（）{
map.dispose（）；
renderer.dispose（）；
世界。处置（）；
b2dr.dispose（）；
dispose（）；
}
}
公共类DBZ扩展游戏{
公共SpriteBatch批次；
公共静态最终内部V_宽度=400；
公共静态最终内部V_高度=208；
公共静态最终浮动PPM=100；
@凌驾
公共void创建（）{
批次=新的SpriteBatch（）；
设置屏幕（新的播放屏幕（本））；
}
@凌驾
公共无效渲染（）{
super.render（）；
}
@凌驾
公共空间处置（）{
batch.dispose（）；
}
}
公共类小悟空扩展精灵{
公共世界；
公共机构；
戈库斯坦私人酒店；
公共小悟空（世界，游戏屏幕）{
super（screen.getAtlas（）.findRegion（“小悟空精灵”）；
这个世界=世界；
defineGoku（）；
gokuStand=新纹理区域（getTexture（），5,12,59,85）；
立根（0,0,59/DBZ.PPM，85/DBZ.PPM）；
setRegion（gokuStand）；
}
公共无效定义库（）{
BodyDef bdef=新的BodyDef（）；
bdef.position.set（32/DBZ.PPM，32/DBZ.PPM）；
bdef.type=BodyDef.BodyType.DynamicBody；
b2body=world.createBody（bdef）；
FixtureDef fdef=新的FixtureDef（）；
多边形形状=新的多边形形状（）；
形状设置框（59/2/DBZ.PPM，85/2/DBZ.PPM）；
fdef.shape=形状；
b2body.createFixture（fdef）；
}
公共无效更新（浮动dt）{
setPosition（b2body.getPosition（）.x-getWidth（）/2，b2body.getPosition（）.y-getHeight（）/2）；
}
}

我相信你想要的是将相机夹在地图上的能力。 这可以使用MathUtils.clamp实现

gameCam.position.x = MathUtils.clamp(gameCam.position.x, viewportWidth/2 , 38 - viewportWidth/2);
gameCam.position.y = MathUtils.clamp(gameCam.position.y, viewportHeight/2, 208 - viewportHeight/2);

编辑：更新的播放屏幕：

package com.edwin.game.Screens;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Box2DDebugRenderer;
import com.badlogic.gdx.physics.box2d.World;
import com.badlogic.gdx.utils.viewport.FitViewport;
import com.badlogic.gdx.utils.viewport.Viewport;
import com.edwin.game.DBZ;
import com.edwin.game.Scenes.Hud;
import com.edwin.game.Sprites.Goku;
import com.edwin.game.Tools.B2WorldCreator;

/**
 * Created by Edwin on 3/20/2017.
 */
public class PlayScreen implements Screen {
private  DBZ game;
private OrthographicCamera gameCam;
private Viewport gamePort;
private Hud hud;
private TmxMapLoader maploader;
private TiledMap map;
private OrthogonalTiledMapRenderer renderer;

private World world;
private Box2DDebugRenderer b2dr;

private Goku player;
private TextureAtlas atlas;
private float viewportWidth;
private float viewportHeight;


public PlayScreen(DBZ game){
    atlas = new TextureAtlas("goku.pack");
    this.game=  game;
    gameCam = new OrthographicCamera();
    gamePort = new FitViewport(DBZ.V_WIDTH/DBZ.PPM, DBZ.V_HEIGHT/DBZ.PPM, gameCam);


    hud = new Hud(game.batch);
    maploader= new TmxMapLoader();
    map = maploader.load("level1.tmx");


    renderer = new OrthogonalTiledMapRenderer(map, 1/DBZ.PPM);

    viewportWidth = gamePort.getWorldWidth();
    viewportHeight= gamePort.getWorldHeight();

    world = new World(new Vector2(0,-10),true);
    b2dr = new Box2DDebugRenderer();

    new B2WorldCreator(world,map);

    player = new Goku(world, this);


}

public TextureAtlas getAtlas(){
    return atlas;
}

@Override
public void show() {

}

public void handleInput(float dt){
    if (Gdx.input.isKeyJustPressed(Input.Keys.UP))
        player.b2body.applyLinearImpulse(new Vector2(0, 4f), player.b2body.getWorldCenter(), true);
    if (Gdx.input.isKeyPressed(Input.Keys.RIGHT) && player.b2body.getLinearVelocity().x <= 2)
        player.b2body.applyLinearImpulse(new Vector2(0.5f, 0), player.b2body.getWorldCenter(), true);
    if (Gdx.input.isKeyPressed(Input.Keys.LEFT) && player.b2body.getLinearVelocity().x >= -2)
        player.b2body.applyLinearImpulse(new Vector2(-0.1f, 0), player.b2body.getWorldCenter(), true);

}

public void update(float dt){
    handleInput(dt);

    world.step(1/60f, 6, 2);
    player.update(dt);
    gameCam.position.x = player.b2body.getPosition().x;

    // cam pos                          / var to clamp       / min val          / max val
    gameCam.position.x = MathUtils.clamp(gameCam.position.x, viewportWidth/2 , 38 - viewportWidth/2);
    gameCam.position.y = MathUtils.clamp(gameCam.position.y, viewportHeight/2, 208 - viewportHeight/2);

    System.out.println(gameCam.position.x);


    gameCam.update();
    renderer.setView(gameCam);

}

@Override
public void render(float delta) {
    update(delta);
    Gdx.gl.glClearColor(0, 0, 0, 0);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    renderer.render();
    //

    //

    b2dr.render(world, gameCam.combined);

    game.batch.setProjectionMatrix(gameCam.combined);
    game.batch.begin();
    player.draw(game.batch);
    game.batch.end();

    game.batch.setProjectionMatrix(hud.stage.getCamera().combined);
    hud.stage.draw();

}

@Override
public void resize(int width, int height) {
    gamePort.update(width, height);


}

@Override
public void pause() {

}

@Override
public void resume() {

}

@Override
public void hide() {

}

@Override
public void dispose() {
    map.dispose();
    renderer.dispose();
    world.dispose();
    b2dr.dispose();
    hud.dispose();

}
}

package com.edwin.game.Screens；
导入com.badlogic.gdx.gdx；
导入com.badlogic.gdx.Input；
导入com.badlogic.gdx.Screen；
导入com.badlogic.gdx.graphics.GL20；
导入com.badlogic.gdx.graphics.Orthographic Camera；
导入com.badlogic.gdx.graphics.g2d.TextureAtlas；
导入com.badlogic.gdx.maps.tiled.TiledMap；
导入com.badlogic.gdx.maps.tiled.TmxMapLoader；
导入com.badlogic.gdx.maps.tiled.renders.OrthogonalTiledMapRenderer；
导入com.badlogic.gdx.math.MathUtils；
导入com.badlogic.gdx.math.Vector2；
导入com.badlogic.gdx.physics.box2d.box2debugrender；
导入com.badlogic.gdx.physics.box2d.World；
导入com.badlogic.gdx.utils.viewport.FitViewport；
导入com.badlogic.gdx.utils.viewport.viewport；
导入com.edwin.game.DBZ；
导入com.edwin.game.Scenes.Hud；
导入com.edwin.game.Sprites.Goku；
导入com.edwin.game.Too
public float gokuStartingPositionX;

public PlayScreen(DBZ game){
    .....
    new B2WorldCreator(world,map);

    gokuStartingPositionX=64/DBZ.PPM;  //added in your method
    player = new Goku(world, this);
} 

public void update(float dt){
    handleInput(dt);

    world.step(1/60f, 6, 2);
    player.update(dt);
    //camera position is decided by player position and keep camera in this way so it cover whole viewport width with screen
    gameCam.position.x = player.b2body.getPosition().x + gamePort.getWorldWidth()/2 - gokuStartingPositionX;

    gameCam.update();
    renderer.setView(gameCam);
}

public Goku(World world, PlayScreen screen){
    super(screen.getAtlas().findRegion("goku_sprite"));
    this.world = world;
    defineGoku(screen.gokuStartingPositionX);

    gokuStand = new TextureRegion(getTexture(), 5,12,59,85);
    setBounds(0,0,59/DBZ.PPM,85/DBZ.PPM);
    setRegion(gokuStand);

}

public void defineGoku(float startX){
    BodyDef bdef = new BodyDef();
    bdef.position.set(startX,32/DBZ.PPM);
    bdef.type = BodyDef.BodyType.DynamicBody;
    b2body = world.createBody(bdef);
    ... 
}