path-game/src/pathgame/rendering/Camera.java

package pathgame.rendering;

import pathgame.gameplay.Gamestate;
import pathgame.gameplay.Gamestates;
import pathgame.gameplay.Keys;
import pathgame.gameplay.Level;

public class Camera {
    private final static int CAM_SPEED = 64;

    private float lastScale = 1.0f;
    private float scale = 1.0f;

    private float lastCamOffsetX = 0.0f;
    private float lastCamOffsetY = 0.0f;
    private float camOffsetX = 0.0f;
    private float camOffsetY = 0.0f;

    public void tick(Level level, Gamestate gamestate, Keys keys) {
        lastCamOffsetX = camOffsetX;
        lastCamOffsetY = camOffsetY;
        lastScale = scale;

        if(!level.getPlayer().isMoving() && gamestate.is(Gamestates.GAMEPLAY)) {
            if(keys.zoomIn.isDown()) {
                scale *= 1.1f;
            } else if(keys.zoomOut.isDown()) {
                scale /= 1.1f;
            }

            if(keys.cameraUp.isDown()) {
                camOffsetY += CAM_SPEED;
            }
            if(keys.cameraDown.isDown()) {
                camOffsetY -= CAM_SPEED;
            }
            if(keys.cameraLeft.isDown()) {
                camOffsetX += CAM_SPEED;
            }
            if(keys.cameraRight.isDown()) {
                camOffsetX -= CAM_SPEED;
            }
        }
    }

    public void limitScale(float zoomRestriction) {
        if(scale <= zoomRestriction) {
            scale = zoomRestriction;
        }
        if(lastScale <= zoomRestriction) {
            lastScale = zoomRestriction;
        }

    }

    public void reset() {
        camOffsetX = 0.0f;
        camOffsetY = 0.0f;
        lastCamOffsetX = 0.0f;
        lastCamOffsetY = 0.0f;
    }

    public float getInterpolatedScale(float lag) {
        return lastScale + (scale - lastScale) * lag;
    }

    public float getCamOffsetX(float offX, float minOffX, float lag, float interScale) {
        float interCamX = lastCamOffsetX + (camOffsetX - lastCamOffsetX) * lag;
        if(offX + interCamX > 0.0f) {
            camOffsetX = -offX;
            if(lastCamOffsetX > camOffsetX) {
                lastCamOffsetX = camOffsetX;
            }
            interCamX = lastCamOffsetX + (camOffsetX - lastCamOffsetX) * lag;
        }
        if(offX + interCamX < minOffX) {
            camOffsetX = minOffX - offX;
            if(lastCamOffsetX < camOffsetX) {
                lastCamOffsetX = camOffsetX;
            }
            interCamX = lastCamOffsetX + (camOffsetX - lastCamOffsetX) * lag;
        }
        return offX + interCamX;
    }

    public float getCamOffsetY(float offY, float minOffY, float lag, float interScale) {
        float interCamY = lastCamOffsetY + (camOffsetY - lastCamOffsetY) * lag;
        if(offY + interCamY > 0.0f) {
            camOffsetY = -offY;
            if(lastCamOffsetY > camOffsetY) {
                lastCamOffsetY = camOffsetY;
            }
            interCamY = lastCamOffsetY + (camOffsetY - lastCamOffsetY) * lag;
        }
        if(offY + interCamY < minOffY) {
            camOffsetY = minOffY - offY;
            if(lastCamOffsetY < camOffsetY) {
                lastCamOffsetY = camOffsetY;
            }
            interCamY = lastCamOffsetY + (camOffsetY - lastCamOffsetY) * lag;
        }
        return offY + interCamY;
    }
}