Actores y Escenarios.

Actores y Escenarios.

Saludos de nuevo, ésta semana nos vamos a meter de lleno en la creación de escenas 2D, al crear una escena 2D tendremos varias ventajas que hasta ahora no teniamos, entre ellas podremos crear actores, que son objetos con su propio sistema de coordenadas, control de gestos con listeners y creación de acciones.

Hay muchas maneras de programar y muchas maneras de hacer las cosas, yo en éste blog explico como sabreís  mis experiencias personales y mis conocimientos adquiridos, digo ésto porque me gusta separar lo más posible la estructura y tener un poco de orden, que al principio tal vez no haga falta, pero con el tiempo es prácticamente necesario.

Estructura Actual.

Estructura Nueva.

Como veís en la nueva estructura añadiremos una classe exclusivamente para la lógica del juego en la cual podremos cargar los diferentes actores. El escenario lo tendriamos en la classe Screen y le añadiriamos el actor Logica que es una "Table" una classe preparada para alojar más actores, imaginaosla como una pizzarra en blanco. Bien, vamos a empezar por el final, y iremos escalando hasta la classe Screen que ya conocemos.

Actores.

Primero de todo vamos a crear una classe que extienda de "Actor" y vamos a añadirle un par de métodos para luego moverlo.


package com.Firedark.libgdxspain;
import com.badlogic.gdx.scenes.scene2d.Actor;

public class Background extends Actor{
   
     //Método Constructor
    public Background(){

    }
   
    //Método Draw, funciona para dibujar el actor, si el actor tiene alguna imagen podemos dibujarla
    //aqui con con el SpriteBatch del método.
    public void draw(SpriteBatch batch,float parentAlpha){    
    }
}
Ésto es un pequeño ejemplo de un actor vacío, dentro del mismo podriamos añadir acciones, listeners, etc, no obstante nos concentraremos en éste articulo a la creación de la estructura así que voy a crear un actor estático sin nada más que nuestro fondo.

package com.Firedark.libgdxspain;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.scenes.scene2d.Actor;

public class Background extends Actor{
   
    //Atributos, me traigo a mi actor la instancia de "Game" de siempre.
    LibgdxSpain game;
    //Creo los atributos para la gestión de la imagen del fondo.
    TextureRegion background;
    Texture Tbackground;
   

    public Background(LibgdxSpain game){
        this.game = game;
        //Éstos són de los métodos básicos que nos ofrecen los actores, posición y tamaño.
        setPosition(0,0);
        setHeight(480);
        setWidth(800);
        //Instancio las texturas y la region.
        Tbackground = new Texture(Gdx.files.internal("data/Images/oceanbackground.jpg"));
        background = new TextureRegion(Tbackground,0,0,800,480);
    }
   
   
    public void draw(SpriteBatch batch,float parentAlpha){
//En el método draw uso otros métodos de "Actor", recibiendo la coordenada X y Y que he puesto
//con el método del constructor setPosition(X,Y) .
        batch.draw(background, getX(), getY());
       
    }

}
Bien, éste actor al añadirlo a un Stage, nos dibujará nuestro fondo, así que vamos a crear nuestra classe donde almacenaremos y añadiremos todos nuestros actores.


Logica. El actor Table.

El actor Table va a ser nuestro intermediario entre el Stage (Escenario) y los actores, y nos servirá para alojar toda la lógica de esa pantalla, en caso de que sea el juego que hemos ido creando en los tutoriales, pondriamos toda la parte de la gamba y el pez, las rocas, los bucles de las colisiones, etc.

Pongo el código y lo explico en los comentarios.

package com.Firedark.libgdxspain;

import com.badlogic.gdx.scenes.scene2d.ui.Table;

//extiende de Table
public class LogicalSplash extends Table {
    LibgdxSpain game;
    //Creamos el atributo para nuestro actor anterior Background
    Background bg;
   
    public LogicalSplash(LibgdxSpain game, SplashScreen screen){
        //El metodo setbounds coloca un Rectangulo (X,Y,Width,Height)
        setBounds(0, 0, 800, 480);
        setClip(true);
        this.game = game;
       
        //Instanciar Actores
        bg = new Background(game);                       
        //Añadiendo Actores
        addActor(bg);
       
    }
       
    //Metodo act se ejecuta al igual que el render, es donde insertaremos la lógica.
    @Override
     public void act(float delta) {
      super.act(delta);    
    }
    //Método Draw contiene el SpriteBatch para dibujar.
    @Override
     public void draw(SpriteBatch batch, float parentAlpha) {
      batch.setColor(Color.WHITE);
      super.draw(batch, parentAlpha);
     }
}

Añadiendo lógica al Screen

Finalmente vamos a añadir nuestra lógica al Screen:

 package com.Firedark.libgdxspain;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.scenes.scene2d.Stage;

public class SplashScreen implements Screen{

    private LibgdxSpain game;
    //Creamos un Stage y el actor LogicalSplash
    private Stage stage;
    private LogicalSplash ls ;
  
    public SplashScreen(LibgdxSpain game){
        this.game = game;
        //Instanciamos el Stage.
        this.stage = new Stage();
      
    }
  
  
    @Override
    public void show() {
        //Ésto es necesario para procesar entradas dentro del stage, para listeners y demás.
        Gdx.input.setInputProcessor(stage);
        //Instancio el actor LogicalSplash anterior
        ls = new LogicalSplash(game,this);
        //Se lo añado al Stage.
        stage.addActor(ls);
    }
  
    @Override
    public void render(float delta) {
        //Ésto pintará de color Negro la pantalla para cuando usemos otras resoluciones si decimos que
        //mantenga las proporciones.
            Gdx.gl.glClearColor(0, 0, 0, 1);
            Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
            //Llama al metodo act y draw del stage.
            stage.act(delta);
            stage.draw();
      
    }

    @Override
    public void resize(int width, int height) {
        //Ésto mantendrá la resolución de la pantalla y ajustará la camara del Stage.
        stage.setViewport(game.w, game.h, true);
        stage.getCamera().translate(-stage.getGutterWidth(),
                -stage.getGutterHeight(), 0);
      
    }


    @Override
    public void hide() {
        //Al ocultar perdemos el procesador de entradas del stage.
         Gdx.input.setInputProcessor(null);
      
    }

    @Override
    public void pause() {

      
    }

    @Override
    public void resume() {
            
    }

    @Override
    public void dispose() {

      
    }

}

Con ésto ya nos cargará el Stage y el actor Background. Próximamente añadiré acciones y listeners de los actores así como detectores de gestos, espero hacerlo antes de la semana que viene. Gracias y espero que sea útil el contenido nuevo sobre las scenes2d. Saludos!