WIP: Desarrollo v0.1.15

build.gradle

@@ -59,8 +59,8 @@ subprojects {
     apply plugin: "java-library"
 
     // Establecemos la version de Java a usar.
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
 
     // Configuraciones del compilador Java
     tasks.withType(JavaCompile) {

client/build.gradle

@@ -5,12 +5,10 @@ dependencies {
     implementation group: "org.jetbrains", name: "annotations", version: "19.0.0"
     implementation group: "com.badlogicgames.gdx", name: "gdx-freetype", version: "$gdxVersion"
     implementation group: "com.badlogicgames.gdx", name: "gdx-freetype", version: "$gdxVersion"
+    implementation group: "com.badlogicgames.gdx", name: "gdx-backend-lwjgl3", version: "$gdxVersion"
     implementation (group: "com.badlogicgames.gdx", name: "gdx-tools", version: "$gdxVersion") {
         exclude group: "com.badlogicgames.gdx", module: "gdx-backend-lwjgl"
     }
-    // @todo: Revisar estas dependencias
-    api group: "com.badlogicgames.gdx", name: "gdx-backend-lwjgl3", version: "$gdxVersion"
-    implementation group: "com.badlogicgames.gdx-controllers", name: "gdx-controllers-core", version: "$gdxControllerVersion"
-    //implementation group: "com.badlogicgames.gdx-controllers", name: "gdx-controllers-desktop", version: "$gdxControllerVersion"
+    implementation group: 'net.mostlyoriginal.artemis-odb', name: 'contrib-plugin-profiler', version: '2.5.0'
     implementation group: "org.reflections", name: "reflections", version: "$reflectionsVersion"
 }

client/src/game/AOGame.java

@@ -3,6 +3,7 @@
 import com.artemis.World;
 import com.badlogic.gdx.ApplicationListener;
 import com.badlogic.gdx.Game;
+import com.badlogic.gdx.utils.PerformanceCounter;
 import com.esotericsoftware.minlog.Log;
 import game.handlers.DefaultAOAssetManager;
 import game.screens.LoadingScreen;
@@ -11,6 +12,9 @@
 import game.systems.resources.MusicSystem;
 import shared.util.LogSystem;
 
+import static game.screens.ScreenEnum.GAME;
+import static game.screens.ScreenEnum.LOGIN;
+
 /**
  * Esta es la <b>clase principal</b> de la aplicación.
  * Ver la documentación de libGDX sobre {@link ApplicationListener}
@@ -30,6 +34,7 @@ public class AOGame extends Game {
     public AOGame(ClientConfiguration clientConfiguration) {
         Log.setLogger(new LogSystem());
         this.clientConfiguration = clientConfiguration;
+        musicSystem = new MusicSystem();
     }
 
     // Crea la ventana del juego.
@@ -40,26 +45,23 @@ public void create() {
         assetManager = DefaultAOAssetManager.getInstance();
         LoadingScreen screen = new LoadingScreen(assetManager);
         setScreen(screen);
+
         screen.onFinished((assetManager) -> {
             ScreenManager screenManager = new ScreenManager(this);
-            this.world = WorldConstructor.create(clientConfiguration, screenManager, assetManager);
-            screenManager.to(ScreenEnum.LOGIN);
-            this.musicSystem = world.getSystem(MusicSystem.class);
-            musicSystem.playMusic(101, true);
+            this.world = WorldConstructor.create(clientConfiguration, screenManager, assetManager, musicSystem);
+            world.inject(musicSystem);
             screenManager.addListener((screenEnum -> {
                 switch (screenEnum) {
                     case LOGIN:
-                        this.musicSystem = world.getSystem(MusicSystem.class);
-                        musicSystem.stopMusic();
-                        this.world = WorldConstructor.create(clientConfiguration, screenManager, assetManager);
-                        this.musicSystem = world.getSystem(MusicSystem.class);
+                        this.world = WorldConstructor.create(clientConfiguration, screenManager, assetManager, musicSystem);
                         musicSystem.playMusic(101, true);
                         break;
                     case GAME:
-                        this.musicSystem = world.getSystem(MusicSystem.class);
                         musicSystem.playMusic(1, true);
+                        break;
                 }
             }));
+            screenManager.to(LOGIN);
         });
     }
 

client/src/game/PixelPerfectViewport.java

@@ -0,0 +1,121 @@
+package game;
+
+import com.badlogic.gdx.graphics.Camera;
+import com.badlogic.gdx.graphics.OrthographicCamera;
+import com.badlogic.gdx.utils.Scaling;
+import com.badlogic.gdx.utils.viewport.Viewport;
+
+import static com.badlogic.gdx.utils.Scaling.fill;
+import static com.badlogic.gdx.utils.Scaling.fit;
+
+
+/**
+ * A viewport that scales the world using {@link Scaling}, but limits the scaling to integer multiples or simple halving
+ * if the zoom would be 0x. Handy for keeping a pixelated look on high-DPI screens. The {@code conversionX} and {@code conversionY}
+ * configurations correspond to the scaling difference from a screen pixel to a world unit.
+ * <p>
+ * {@link Scaling#fit} keeps the aspect ratio by scaling the world up to fit the screen, adding black bars (letterboxing) for the
+ * remaining space.
+ * <p>
+ * {@link Scaling#fill} keeps the aspect ratio by scaling the world up to take the whole screen (some of the world may be off
+ * screen, potentially in both directions regardless of whether fill, fillX, or fillY is used).
+ * <p>
+ * {@link Scaling#stretch} (NOT RECOMMENDED) does not keep the aspect ratio, the world is scaled to take the whole screen. It is not pixel perfect.
+ * <p>
+ * {@link Scaling#none} keeps the aspect ratio by using a fixed size world (the world may not fill the screen or some of the world
+ * may be off screen).
+ *
+ * @author Daniel Holderbaum
+ * @author Nathan Sweet
+ * @author Tommy Ettinger
+ */
+public class PixelPerfectViewport extends Viewport {
+
+    private Scaling scaling;
+    private int conversionX, conversionY;
+    private float currentScale = 1;
+    /**
+     * Creates a new viewport using a new {@link OrthographicCamera}.
+     */
+    public PixelPerfectViewport(Scaling scaling, float worldWidth, float worldHeight, int conversionX, int conversionY) {
+        this(scaling, worldWidth, worldHeight, conversionX, conversionY, new OrthographicCamera());
+    }
+    public PixelPerfectViewport(Scaling scaling, float worldWidth, float worldHeight, int conversion) {
+        this(scaling, worldWidth, worldHeight, conversion, conversion, new OrthographicCamera());
+    }
+
+    public PixelPerfectViewport(Scaling scaling, float worldWidth, float worldHeight, int conversionX, int conversionY, Camera camera) {
+        this.scaling = scaling;
+        this.conversionX = conversionX;
+        this.conversionY = conversionY;
+        setWorldSize(worldWidth, worldHeight);
+        setCamera(camera);
+    }
+
+    @Override
+    public void update(int screenWidth, int screenHeight, boolean centerCamera) {
+        //Vector2 scaled = scaling.apply(getWorldWidth(), getWorldHeight(), screenWidth, screenHeight);
+        float worldWidth = getWorldWidth(), worldHeight = getWorldHeight();
+
+        int viewportWidth = 0;
+        int viewportHeight = 0;
+
+        if (fit.equals(scaling)) {
+            float screenRatio = screenHeight / (float) screenWidth;
+            float worldRatio = worldHeight / worldWidth;
+            float scale = (int) (screenRatio > worldRatio ? screenWidth / (worldWidth * conversionX) : screenHeight / (worldHeight * conversionY));
+            if (scale < 1) scale = 0.5f;
+            viewportWidth = Math.round(worldWidth * scale);
+            viewportHeight = Math.round(worldHeight * scale);
+            this.currentScale = 1f / scale;
+        } else if (fill.equals(scaling)) {
+            float screenRatio = screenHeight / (float) screenWidth;
+            float worldRatio = worldHeight / worldWidth;
+            float scale = (int) Math.ceil(screenRatio < worldRatio ? screenWidth / (worldWidth * conversionX) : screenHeight / (worldHeight * conversionY));
+            if (scale < 1) scale = 0.5f;
+            viewportWidth = Math.round(worldWidth * scale);
+            viewportHeight = Math.round(worldHeight * scale);
+            this.currentScale = 1f / scale;
+        } else if (Scaling.fillX.equals(scaling)) {
+            float scale = (int) Math.ceil(screenWidth / (worldWidth * conversionX));
+            if (scale < 1) scale = 0.5f;
+            viewportWidth = Math.round(worldWidth * scale);
+            viewportHeight = Math.round(worldHeight * scale);
+            this.currentScale = 1f / scale;
+        } else if (Scaling.fillY.equals(scaling)) {
+            float scale = (int) Math.ceil(screenHeight / (worldHeight * conversionY));
+            if (scale < 1) scale = 0.5f;
+            viewportWidth = Math.round(worldWidth * scale);
+            viewportHeight = Math.round(worldHeight * scale);
+            this.currentScale = 1f / scale;
+        } else if (Scaling.stretch.equals(scaling)) {
+            viewportWidth = screenWidth;
+            viewportHeight = screenHeight;
+        } else if (Scaling.stretchX.equals(scaling)) {
+            viewportWidth = screenWidth;
+            viewportHeight = (int) worldHeight;
+        } else if (Scaling.stretchY.equals(scaling)) {
+            viewportWidth = (int) worldWidth;
+            viewportHeight = screenHeight;
+        } else {
+            viewportWidth = (int) worldWidth;
+            viewportHeight = (int) worldHeight;
+        }
+        // Center.
+        setScreenBounds((screenWidth - viewportWidth * conversionX) / 2, (screenHeight - viewportHeight * conversionY) / 2, viewportWidth * conversionX, viewportHeight * conversionX);
+
+        apply(centerCamera);
+    }
+
+    public Scaling getScaling() {
+        return scaling;
+    }
+
+    public void setScaling(Scaling scaling) {
+        this.scaling = scaling;
+    }
+
+    public float getCurrentScale() {
+        return currentScale;
+    }
+}

client/src/game/WorldConstructor.java

@@ -22,7 +22,11 @@
 import game.systems.physics.MovementProcessorSystem;
 import game.systems.physics.MovementSystem;
 import game.systems.physics.PlayerInputSystem;
-import game.systems.render.BatchRenderingSystem;
+import game.systems.profiling.ProfilerSystem;
+import game.systems.render.BatchBeginSystem;
+import game.systems.render.BatchEndSystem;
+import game.systems.render.BatchSystem;
+import game.systems.render.chars.PrerenderCharCache;
 import game.systems.render.world.*;
 import game.systems.resources.*;
 import game.systems.screen.MouseSystem;
@@ -41,6 +45,7 @@
 import game.systems.world.WorldSystem;
 import game.utils.CursorSystem;
 import net.mostlyoriginal.api.system.render.ClearScreenSystem;
+import net.mostlyoriginal.plugin.ProfilerPlugin;
 import shared.systems.IntervalSystem;
 
 import java.util.Arrays;
@@ -56,7 +61,12 @@ public class WorldConstructor {
     private static final int DECORATION_PRIORITY = 3;
     private static final int UI = 0;
 
-    private static WorldConfiguration getWorldConfiguration(ClientConfiguration clientConfiguration, ScreenManager screenManager, DefaultAOAssetManager assetManager) {
+    private static WorldConfiguration getWorldConfiguration(
+            ClientConfiguration clientConfiguration,
+            ScreenManager screenManager,
+            DefaultAOAssetManager assetManager,
+            MusicSystem musicSystem
+    ) {
         return new WorldConfigurationBuilder()
                 // Sistemas de uso global (no necesitan prioridad porque son pasivos)
                 .with(clientConfiguration,
@@ -106,7 +116,6 @@ private static WorldConfiguration getWorldConfiguration(ClientConfiguration clie
                         new DescriptorsSystem(),
                         new MessageSystem(),
                         new MapSystem(),
-                        new MusicSystem(),
                         new ObjectSystem(),
                         new ParticlesSystem(),
                         new SoundsSystem(),
@@ -119,6 +128,9 @@ private static WorldConfiguration getWorldConfiguration(ClientConfiguration clie
 
                 // Rendering
                 .with(PRE_ENTITY_RENDER_PRIORITY,
+                        new BatchSystem(),
+                        new BatchBeginSystem(),
+                        new PrerenderCharCache(),
                         new ClearScreenSystem(),
                         new MapGroundRenderingSystem(),
                         new ObjectRenderingSystem(),
@@ -127,7 +139,7 @@ private static WorldConfiguration getWorldConfiguration(ClientConfiguration clie
 
                 .with(ENTITY_RENDER_PRIORITY,
                         new EffectRenderingSystem(),
-                        new CharacterRenderingSystem(),
+                        new CharacterRenderSystem(),
                         new WorldRenderingSystem())
 
                 .with(POST_ENTITY_RENDER_PRIORITY,
@@ -138,7 +150,7 @@ private static WorldConfiguration getWorldConfiguration(ClientConfiguration clie
                 .with(DECORATION_PRIORITY,
                         new StateRenderingSystem(),
                         new CharacterStatesRenderingSystem(),
-                        new BatchRenderingSystem())
+                        new BatchEndSystem())
 
                 // UI
                 .with(UI,
@@ -156,18 +168,23 @@ private static WorldConfiguration getWorldConfiguration(ClientConfiguration clie
                 // Otros sistemas
                 .with(new MapManager(),
                         new TagManager(),
-                        new UuidEntityManager())
-
+                        new UuidEntityManager(),
+                        new ProfilerSystem())
                 .build()
-                .register(assetManager);
+                .register(assetManager)
+                .register(musicSystem);
     }
 
     /**
      * Construye el Artemis World, inicializa e inyecta sistemas.
      * Este método es bloqueante.
      */
-    public static World create(ClientConfiguration clientConfiguration,
-                               ScreenManager screenManager, DefaultAOAssetManager assetManager) {
-        return new World(getWorldConfiguration(clientConfiguration, screenManager, assetManager));
+    public static World create(
+            ClientConfiguration clientConfiguration,
+            ScreenManager screenManager,
+            DefaultAOAssetManager assetManager,
+            MusicSystem musicSystem
+    ) {
+        return new World(getWorldConfiguration(clientConfiguration, screenManager, assetManager, musicSystem));
     }
 }

client/src/game/handlers/AOAssetManager.java

@@ -8,6 +8,7 @@
 import com.badlogic.gdx.graphics.g2d.BitmapFont;
 import com.badlogic.gdx.graphics.g2d.ParticleEffect;
 import com.badlogic.gdx.graphics.g2d.TextureAtlas;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
 import com.badlogic.gdx.scenes.scene2d.ui.Skin;
 import model.descriptors.*;
 import model.textures.AOAnimation;

client/src/game/handlers/DefaultAOAssetManager.java

@@ -14,6 +14,7 @@
 import com.badlogic.gdx.graphics.g2d.ParticleEffect;
 import com.badlogic.gdx.graphics.g2d.TextureAtlas;
 import com.badlogic.gdx.utils.I18NBundle;
+import com.badlogic.gdx.utils.PerformanceCounter;
 import com.esotericsoftware.minlog.Log;
 import game.ClientConfiguration;
 import game.loaders.*;
@@ -76,6 +77,7 @@ public class DefaultAOAssetManager extends AssetManager implements AOAssetManage
     private Map<Integer, HelmetDescriptor> helmets;
     private Map<Integer, WeaponDescriptor> weapons;
     private Map<Integer, BodyDescriptor> bodies;
+    private TextureAtlas textureAtlas;
 
     private DefaultAOAssetManager(ClientConfiguration clientConfiguration) {
         this.languagesFile = SharedResources.LANGUAGES_FOLDER + "messages";
@@ -113,6 +115,11 @@ public void load() {
         loadSkins();
         loadFonts();
         loadMessages();
+        loadAtlas();
+    }
+
+    private void loadAtlas() {
+        load(Resources.GAME_ATLAS_PATH + "images.atlas", TextureAtlas.class);
     }
 
     @Override
@@ -342,7 +349,7 @@ private void loadTexture(String fileName) {
         TextureParameter param = new TextureParameter();
         param.minFilter = TextureFilter.Linear;
         param.magFilter = TextureFilter.Linear;
-        param.genMipMaps = true;
+        param.genMipMaps = false;
         param.wrapU = Texture.TextureWrap.Repeat;
         param.wrapV = Texture.TextureWrap.Repeat;
         load(fileName, Texture.class, param);

client/src/game/loaders/ImageLoader.java

@@ -43,9 +43,9 @@ public void loadAsync(AssetManager manager, String fileName, FileHandle file, De
 
     @Override
     public ArrayList<AOImage> loadSync(AssetManager manager, String fileName, FileHandle file, DescriptorParameter parameter) {
-        ArrayList<AOImage> syncronizedDescriptors = this.descriptors;
+        ArrayList<AOImage> synchronizedDescriptors = this.descriptors;
         this.descriptors = null;
-        return syncronizedDescriptors;
+        return synchronizedDescriptors;
     }
 
     @Override

client/src/game/screens/AbstractScreen.java

@@ -14,7 +14,7 @@
 import net.mostlyoriginal.api.system.core.PassiveSystem;
 
 public abstract class AbstractScreen extends PassiveSystem implements Screen {
-    private static final Skin SKIN = Skins.COMODORE_SKIN;
+    private static final Skin SKIN = Skins.CURRENT.get();
     private static final Texture BACKGROUND_TEXTURE = new Texture(Gdx.files.internal(Resources.GAME_IMAGES_PATH + "background.jpg"));
     private static final SpriteDrawable BACKGROUND = new SpriteDrawable(new Sprite(BACKGROUND_TEXTURE));
 
@@ -72,7 +72,7 @@ public void render(float delta) {
 
     @Override
     public void resize(int width, int height) {
-        getStage().getViewport().update(width, height);
+//        getStage().getViewport().update(width, height);
     }
 
     @Override