Es tiempo de modificar la clase Main.java y crear el Singleton principal GM.java (Game Manager) junto con la primera escena.
public class GM {
public static final float SHORT_WORLD_DIM = 1080;
public static final float LARGE_WORLD_DIM = 1920;
public Main GAME;
private static final GM INSTANCE = new GM();
public static GM get() {
return INSTANCE;
}
public void Init(Main game) {
this.GAME = game;
}
public void dispose() {
}
}
Una característica que voy a implementar, es la habilidad de adaptarse a cualquier orientación o tamaño de pantalla. En cualquier momento, si deseas girar el teléfono, no afectaría nada.
Las lineas 3 y 4 solo indican la disponibilidad garantizada en pixeles pero si ese aspecto (16:9) resulta no igual al dispositivo pues simplemente se añaden mas pixeles para llenar la pantalla.
La razón de llamarlas “Short” (pequeña) y “Large” (Grande) es porque cada una puede ser alto o ancho dependiendo de la orientación actual.
Lo demás es la estructura típica de un Singleton que garantiza una sola instancia.
public class Main extends com.badlogic.gdx.Game {
public Main (CommunicationInterface communicationInterface) {
GM.get().Init(this);
}
@Override
public void create () {
}
@Override
public void dispose () {
getScreen().dispose();
GM.get().dispose();
}
}
Linea 4 inicia el singleton GM y en la línea 9 insertamos la primera escena cuando esté lista.
Para organizar y simplificar, divido la escena en dos partes. La base, que incluye código básico para todas las escenas, y de esta base extendemos todas las demás.
public abstract class BaseScreen implements Screen, InputProcessor {
private final Vector3 mTmp;
private final Vector2 mScreenTouch;
protected Stage mStage;
public BaseScreen(Color clearColor) {
mClearColor = clearColor;
mTmp = new Vector3().setZero();
mScreenTouch = new Vector2().setZero();
mStage = new Stage(new ExtendViewport(GM.LARGE_WORLD_DIM, GM.SHORT_WORLD_DIM));
}
@Override
public void show() {
Gdx.input.setInputProcessor(new InputMultiplexer(mStage, this));
Gdx.input.setCatchKey(Input.Keys.BACK, true);
}
@Override
public void render(float delta) {
Gdx.gl.glClearColor(mClearColor.r, mClearColor.g, mClearColor.b, 1);
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
mStage.draw();
mStage.act(delta);
}
@Override
public void resize(int width, int height) {
ExtendViewport stageViewport = (ExtendViewport) mStage.getViewport();
if (width < height) {
stageViewport.setMinWorldWidth(GM.SHORT_WORLD_DIM);
stageViewport.setMinWorldHeight(GM.LARGE_WORLD_DIM);
} else {
stageViewport.setMinWorldWidth(GM.LARGE_WORLD_DIM);
stageViewport.setMinWorldHeight(GM.SHORT_WORLD_DIM);
}
stageViewport.update(width, height, true);
resetActors();
}
protected void resetActors() {}
@Override
public void dispose() {
mStage.dispose();
}
@Override
public void pause() {}
@Override
public void resume() {}
@Override
public void hide() {
dispose();
}
@Override
public boolean keyDown(int keycode) {
return false;
}
@Override
public boolean keyUp(int keycode) {
return false;
}
@Override
public boolean keyTyped(char character) {
return false;
}
@Override
public boolean touchCancelled(int screenX, int screenY, int pointer, int button) {
return false;
}
@Override
public boolean touchDown(int screenX, int screenY, int pointer, int button) {
mTmp.set(mStage.getCamera().unproject(mTmp.set(screenX, screenY, 0)));
mScreenTouch.set(mTmp.x, mTmp.y);
onStageTouchDown(mScreenTouch, pointer, button);
return false;
}
@Override
public boolean touchUp(int screenX, int screenY, int pointer, int button) {
mTmp.set(mStage.getCamera().unproject(mTmp.set(screenX, screenY, 0)));
mScreenTouch.set(mTmp.x, mTmp.y);
onStageTouchUp(mScreenTouch, pointer, button);
return false;
}
@Override
public boolean touchDragged(int screenX, int screenY, int pointer) {
mTmp.set(mStage.getCamera().unproject(mTmp.set(screenX, screenY, 0)));
mScreenTouch.set(mTmp.x, mTmp.y);
onStageDragged(mScreenTouch);
return false;
}
protected void onStageTouchDown(Vector2 touch, int pointer, int button) {}
protected void onStageTouchUp(Vector2 touch, int pointer, int button) {}
protected void onStageDragged(Vector2 touch) {}
@Override
public boolean mouseMoved(int screenX, int screenY) {
return false;
}
@Override
public boolean scrolled(float amountX, float amountY) {
return false;
}
}
Las líneas 41 a la 47 es el código que modifica las dimensiones disponibles cuando el dispositivo cambia de orientación y se adapta a cualquier dimensión. El método «resetActors» en la línea 54 es solo para separar el código que voy a usar para reposicionar lo necesario cuando ocurra cualquier cambio de dimensión.
Los métodos de contacto «touchDown», «touchUp» y «touchDragged» los reemplazo con métodos que ya calculan la posición del evento tomando en consideración la cámara. De ahora en adelante, solo necesito los métodos «onStageTouchDown», «onStageTouchUp» y «onStageDragged».
Proximo Sábado, si Dios lo permite, preparo la primera escena «Intro».
AVISO: PARTES O LA TOTALIDAD DE ESTA PUBLICACION PUEDEN O NO SER FICTICIAS Y ESTAN DESTINADAS UNICAMENTE A FINES DE ENTRETENIMIENTO.
QUAGEM 
Deja una respuesta