拥有；照相机“；Java中播放器的定位

因此，我在将“摄像机”放置在播放器上时遇到了一些问题，因为这是我第一次尝试实现这一点。每当我启动游戏并移动玩家时，相机似乎不像我希望的那样对准玩家，我不知道它出了什么问题。我试着浏览在线资源，并检查了许多关于堆栈溢出的问题，但我找不到我做错了什么：/。我正在使用Java和Slick2D引擎。以下是我的班级档案：

Camera.class：

private float offsetMaxX;
private float offsetMaxY;
private float offsetMinX = 0;
private float offsetMinY = 0;
public float camX;
public float camY;

public Camera () {
    super ();
}

public void update (float playerX, float playerY, float mapX, float mapY){
    offsetMaxX = mapX - Main.WIDTH;
    offsetMaxY = mapY - Main.HEIGHT;

    camX = playerX - Main.WIDTH/2;
    camY = playerY - Main.HEIGHT/2;

    if (camX > offsetMaxX) {
        camX = offsetMaxX;
    } else if (camX < offsetMinX) {
        camX = offsetMinX;
    }
    if (camY > offsetMaxY) {
        camY = offsetMaxY;
    } else if (camY < offsetMinY) {
        camY = offsetMinY;
    }
}

public float getCamX() {
    return camX;
}

public float getCamY() {
    return camY;
}

public float getOffsetMaxX() {
    return offsetMaxX;
}

public float getOffsetMaxY() {
    return offsetMaxY;
}

public float getOffsetMinX() {
    return offsetMinX;
}

public float getOffsetMinY() {
    return offsetMinY;
}

public void setOffsetMaxX(float offsetMaxX) {
    this.offsetMaxX = offsetMaxX;
}

public void setOffsetMaxY(float offsetMaxY) {
    this.offsetMaxY = offsetMaxY;
}

public void setOffsetMinX(float offsetMinX) {
    this.offsetMinX = offsetMinX;
}

public void setOffsetMinY(float offsetMinY) {
    this.offsetMinY = offsetMinY;
}

private float offsetMaxX；
私人浮动抵消；
私有浮动偏移量minx=0；
私有浮动偏移量miny=0；
公共浮动camX；
大众浮标凯美；
公共摄像机（）{
超级（）；
}
公共void更新（float playerX、float playerY、float mapX、float mapY）{
offsetMaxX=mapX-Main.WIDTH；
offsetMaxY=mapY-Main.HEIGHT；
camX=playerX-Main.WIDTH/2；
camY=playerY-Main.HEIGHT/2；
如果（camX>offsetMaxX）{
camX=offsetMaxX；
}否则如果（camX偏置凸轮轴）{
camY=偏移最大值；
}否则如果（凸轮轴

还有我的游戏。课堂：

// Player variables
public SpriteSheet playerSS = null;
protected InputHandler inputHandler;
public float playerX = Main.WIDTH/2, playerY = Main.HEIGHT/2;
private Animation sprite, runningAnimationLEFT, runningAnimationRIGHT, runningAnimationUP, runningAnimationDOWN;
private Animation standLEFT, standRIGHT, standUP, standDOWN; //THIS IS TO PREVENT ANIMATIONS FROM CONTINUING AFTER THE PLAYER STOPS
private int duration = 300;
public boolean isMoving, isLeft, isRight, isUp, isDown;


//Map
private Image testMap; //This is a test map
private float mapX = 1024, mapY = 1024;

//Camera
public Camera camera;

public Game (int stateID) {}

@Override
public int getID() {
    return Main.game; //GAMESTATE = 1
}

@Override
public void init(GameContainer gameContainer, StateBasedGame stateBasedGame) throws SlickException {
    playerSS = new SpriteSheet("res/characters/player_sprite_sheet.png", 50, 75);
    testMap = new Image ("res/grassMap.png");
    camera = new Camera();

    // ANIMATIONS
    runningAnimationDOWN = new Animation();
    runningAnimationDOWN.setAutoUpdate(true);
    runningAnimationDOWN.addFrame(playerSS.getSprite(1, 0), duration);
    runningAnimationDOWN.addFrame(playerSS.getSprite(0, 0), duration);
    runningAnimationDOWN.addFrame(playerSS.getSprite(2, 0), duration);

    runningAnimationLEFT = new Animation();
    runningAnimationLEFT.setAutoUpdate(true);
    runningAnimationLEFT.addFrame(playerSS.getSprite(1, 1), duration);
    runningAnimationLEFT.addFrame(playerSS.getSprite(0, 1), duration);
    runningAnimationLEFT.addFrame(playerSS.getSprite(2, 1), duration);

    runningAnimationRIGHT = new Animation();
    runningAnimationRIGHT.setAutoUpdate(true);
    runningAnimationRIGHT.addFrame(playerSS.getSprite(1, 2), duration);
    runningAnimationRIGHT.addFrame(playerSS.getSprite(0, 2), duration);
    runningAnimationRIGHT.addFrame(playerSS.getSprite(2, 2), duration);

    runningAnimationUP = new Animation();
    runningAnimationUP.setAutoUpdate(true);
    runningAnimationUP.addFrame(playerSS.getSprite(1, 3), duration);
    runningAnimationUP.addFrame(playerSS.getSprite(0, 3), duration);
    runningAnimationUP.addFrame(playerSS.getSprite(2, 3), duration);

    standDOWN = new Animation();
    standDOWN.setAutoUpdate(true);
    standDOWN.addFrame(playerSS.getSprite(1, 0), duration);

    standLEFT = new Animation();
    standLEFT.setAutoUpdate(true);
    standLEFT.addFrame(playerSS.getSprite(1, 1), duration);

    standRIGHT = new Animation();
    standRIGHT.setAutoUpdate(true);
    standRIGHT.addFrame(playerSS.getSprite(1, 2), duration);

    standUP = new Animation();
    standUP.setAutoUpdate(true);
    standUP.addFrame(playerSS.getSprite(1, 3), duration);

    sprite = standDOWN;
}

@Override
public void update(GameContainer gameContainer, StateBasedGame stateBasedGame, int delta) throws SlickException {
    inputHandler.updateKeyboardRelay(gameContainer);
    isMoving = false;

    if (inputHandler.keyUP) {
        isUp = true;
        isDown = false;
        isLeft = false;
        isRight = false;
        isMoving = true;
        playerY -= delta * 0.1f;
    } else if (inputHandler.keyDOWN) {
        isDown = true;
        isUp = false;
        isLeft = false;
        isRight = false;
        isMoving = true;
        playerY += delta * 0.1f;
    } else if (inputHandler.keyLEFT) {
        isLeft = true;
        isUp = false;
        isDown = false;
        isRight = false;
        isMoving = true;
        playerX -= delta * 0.1f;
    } else if (inputHandler.keyRIGHT) {
        isRight = true;
        isUp = false;
        isDown = false;
        isLeft = false;
        isMoving = true;
        playerX += delta * 0.1f;
    }

    if (isMoving) {
        if (inputHandler.keyUP) {
            sprite = runningAnimationUP;
            sprite.update(delta);
        } else if (inputHandler.keyDOWN) {
            sprite = runningAnimationDOWN;
            sprite.update(delta);
        } else if (inputHandler.keyLEFT) {
            sprite = runningAnimationLEFT;
            sprite.update(delta);
        } else if (inputHandler.keyRIGHT) {
            sprite = runningAnimationRIGHT;
            sprite.update(delta);
        }
    } else {
        if (isDown) {
            sprite = standDOWN;
            sprite.update(delta);
        } else if (isUp) {
            sprite = standUP;
            sprite.update(delta);
        } else if (isLeft) {
            sprite = standLEFT;
            sprite.update(delta);
        } else if (isRight) {
            sprite = standRIGHT;
            sprite.update(delta);
        }
    }

    // Map Boundaries
    if (playerX > mapX) {
        playerX = mapX;
    } else if (playerX < 0) {
        playerX = 0;
    }
    if (playerY > mapY) {
        playerY = mapY;
    } else if (playerY < 0) {
        playerY = 0;
    }

    camera.update(playerX, playerY, mapX, mapY);
}

@Override
public void render(GameContainer gameContainer, StateBasedGame stateBasedGame, Graphics graphics) throws SlickException {
    testMap.draw(mapX - 1024, mapY - 1024);

    graphics.translate(camera.getCamX(), camera.getCamY());
    sprite.draw(playerX, playerY);
    graphics.translate(-camera.getCamX(), -camera.getCamY());

    graphics.drawString("Player X: " + playerX, 400, 400);
    graphics.drawString("Player Y: " + playerY, 400, 415);

}

//播放器变量
公共SpriteSheet Players=null；
受保护的权限管理器中的权限管理器；
公共浮动playerX=Main.WIDTH/2，playerY=Main.HEIGHT/2；
私有动画精灵，runningAnimationLEFT，runningAnimationRIGHT，runningAnimationUP，runningAnimationDOWN；
私人动画standLEFT，standRIGHT，standUP，standDOWN//这是为了防止在播放器停止后继续播放动画
私有整数持续时间=300；
公共布尔值isMoving、isLeft、isRight、isUp、isDown；
//地图
私有图像测试图//这是一张测试图
私有浮点mapX=1024，mapY=1024；
//摄像机
公共摄像机；
公共游戏（int stateID）{}
@凌驾
公共int getID（）{
return Main.game；//GAMESTATE=1
}
@凌驾
public void init（GameContainer GameContainer，StateBasedGame StateBasedGame）引发异常{
playerSS=新精灵表（“res/characters/player\u sprite\u sheet.png”，50,75）；
testMap=新图像（“res/grassMap.png”）；
摄像头=新摄像头（）；
//动画
runningAnimationDOWN=新建动画（）；
runningAnimationDOWN.setAutoUpdate（true）；
runningAnimationDOWN.addFrame（playerSS.getSprite（1,0），持续时间）；
runningAnimationDOWN.addFrame（playerSS.getSprite（0,0），持续时间）；
runningAnimationDOWN.addFrame（playerSS.getSprite（2,0），持续时间）；
runningAnimationLEFT=新动画（）；
runningAnimationLEFT.setAutoUpdate（true）；
runningAnimationLEFT.addFrame（playerSS.getSprite（1,1），持续时间）；
runningAnimationLEFT.addFrame（playerSS.getSprite（0,1），持续时间）；
runningAnimationLEFT.addFrame（playerSS.getSprite（2,1），持续时间）；
runningAnimationRIGHT=新动画（）；
runningAnimationRIGHT.setAutoUpdate（true）；
runningAnimationRIGHT.addFrame（playerSS.getSprite（1,2），持续时间）；
runningAnimationRIGHT.addFrame（playerSS.getSprite（0,2），持续时间）；
runningAnimationRIGHT.addFrame（playerSS.getSprite（2,2），持续时间）；
runningAnimationUP=新建动画（）；
runningAnimationUP.setAutoUpdate（true）；
运行animationup.addFrame（playerSS.getSprite（1,3），持续时间）；
运行animationup.addFrame（playerSS.getSprite（0,3），持续时间）；
运行animationup.addFrame（playerSS.getSprite（2,3），持续时间）；
停机=新建动画（）；
停机。设置自动更新（true）；
暂停.addFrame（players.getSprite（1,0），持续时间）；
standLEFT=新动画（）；
设置自动更新（true）；
standLEFT.addFrame（players.getSprite（1,1），持续时间）；
standRIGHT=新动画（）；
statdright.setAutoUpdate（true）；
standRIGHT.addFrame（players.getSprite（1,2），持续时间）；
站立=新动画（）；
standUP.setAutoUpdate（真）；
站立.addFrame（players.getSprite（1,3），持续时间）；
sprite=停机；
}
@凌驾
公共无效更新（GameContainer GameContainer、StateBasedGame StateBasedGame、int delta）引发异常{
inputHandler.updateKeyboardRelay（游戏容器）；
isMoving=假；
如果（输入权限管理器键控）{
isUp=true；
isDown=假；
isLeft=false；
isRight=false；
isMoving=真；
playerY-=delta*0.1f；
}else if（输入权限管理器键控）{
isDown=真；
isUp=false；
isLeft=false；
isRight=false；
isMoving=真；
playerY+=增量*0.1f；
}else if（输入权限句柄。键左）{
isLeft=true；
isUp=false；
isDown=假；
isRight=false；
isMoving=真；
playerX-=delta*0.1f；
}else if（在权限句柄中，右键）{
isRight=正确；
isUp=false；
isDown=假；
isLeft=false；
isMoving=真；
playerX+=delta*0.1f；
}
如果（正在移动）{
如果（输入权限管理器键控）{
sprite=runningAnimationUP；
sprite.update（delta）；
}else if（输入权限管理器键控）{
sprite=runningAnimationDOWN；
sprite.update（delta）；
}else if（输入权限句柄。键左）{
sprite=runningAnimationLEFT；
sprite.update（delta）；
}
camX = playerX - Main.WIDTH/2;
camY = playerY - Main.HEIGHT/2;

camX = playerX;
camY = playerY;