src/main/scala/engine/objects/Scene.scala

+package Engine
+package Objects
+
+import scala.collection.mutable.ListBuffer
+
+import Components.Component
+
+trait Scene extends GameObject:
+    def addGameObject[T <: GameObject](gameObject: T): T =
+        return addChild(gameObject)
+
+    private[Engine] inline def recursiveComponents[T <: Component]: ListBuffer[T] =
+        val components = getComponents[T]().filter(_.isActive)
+
+        for gameObject <- recursiveChilds do components ++= gameObject.getComponents[T]().filter(_.isActive)
+
+        components

src/main/scala/engine/objects/Sprite.scala

+package Engine
+package Objects
+
+import Components.{Renderer, RendererLayer}
+
+import SFML.Graphics.{Color, FloatRect, IntRect, RenderWindow, Sprite, Texture}
+import SFML.System.{Vector2i, Vector2f}
+
+class Sprite(texture: Texture, var layer: RendererLayer) extends Renderer:
+    private val sprite = SFML.Graphics.Sprite(texture)
+
+    val color = Color()
+
+    val rect = IntRect()
+
+    def draw(window: RenderWindow) =
+        bounds := sprite.getGlobalBounds()
+
+        if rect != IntRect() then sprite.setTextureRect(rect)
+
+        sprite.setColor(color)
+        sprite.setPosition(gameObject.pos)
+        sprite.setScale(Vector2f(gameObject.scale, gameObject.scale))
+        window.draw(sprite)

src/main/scala/engine/objects/Text.scala

+package Engine
+package Objects
+
+import Components.{Renderer, RendererLayer}
+
+import SFML.Graphics.{Color, FloatRect, Font, IntRect, RenderWindow, Text}
+import SFML.System.{Vector2i, Vector2f}
+
+class Text(font: Font, var msg: String, var layer: RendererLayer) extends Renderer:
+    private val text = SFML.Graphics.Text()
+
+    text.setFont(font)
+
+    val color = Color.Black()
+
+    def draw(window: RenderWindow) =
+        bounds := text.getGlobalBounds()
+
+        text.setColor(color)
+        text.setPosition(gameObject.pos)
+        text.setString(msg)
+        window.draw(text)

src/main/scala/engine/objects/Translation.scala

+package Engine
+package Objects
+
+import Components.MonoBehaviour
+
+import SFML.System.Vector2f
+
+class Translation(translation: Vector2f, frame: Int, callback: () => Unit = () => ()) extends MonoBehaviour:
+    private val initialPosition = Vector2f()
+    private val vector = translation * (1 / frame.toFloat)
+    private var currentFrame = 0
+
+    def init(engine: GameEngine): Unit =
+        initialPosition := gameObject.pos * (1 / gameObject.scale)
+
+    def update(engine: GameEngine): Unit =
+        currentFrame = currentFrame + 1
+
+        gameObject.moveTo(initialPosition + (vector * currentFrame))
+
+        if currentFrame == frame then
+            gameObject.moveTo(initialPosition + translation)
+            callback()
+            destroy()

src/main/scala/pokemon/Trainer.scala

@@ -5,8 +5,8 @@ class Trainer(val name: String, var listPokemon: List[Pokemon], var indexPrimary
     def numberPokemon: Int =
         this.listPokemon.length
 
-    def primaryPokemon: Option[Pokemon] =
-        this.listPokemon.lift(this.indexPrimaryPokemon)
+    def primaryPokemon: Pokemon =
+        this.listPokemon.lift(this.indexPrimaryPokemon).get
 
     def changePrimaryPokemon(index: Int): Unit =
         assert(0 <= index && index < this.numberPokemon, "This Pokemon doesn't exists.")

src/main/scala/scene/Scene.scala

-package Scene
-
-import Component.*
-
-trait Scene:
-    var components: List[Drawable] = List()
-
-    protected def addComponent(component: Drawable): Unit =
-        // TODO: Add z-index
-        components = components ::: List(component)
-
-    def load(scene: Main.Game): Unit

src/main/scala/scene/Sprite.scala

-package Scene
-
-import Component.*
-import SFML.Graphics.Texture
-
-class Sprite(texture: Texture) extends DrawableTexture(texture):
-    def init() = ()
-    def update(game: Main.Game) = ()

src/main/scala/scene/Text.scala

-package Scene
-
-import Component.*
-import SFML.Graphics.Font
-
-class Text(font: Font) extends DrawableText(font):
-    def init() = ()
-    def update(game: Main.Game) = ()

src/main/scala/scene/battle/Battle.scala

+package Scene.Battle
+
+import BattleTrainer.{BattleFrontTrainer, BattleBackTrainer}
+
+import Pokemon.Trainer
+
+class Battle(playerTrainer: Trainer, enemyTrainer: Trainer):
+    val backTrainer = BattleBackTrainer(playerTrainer)
+    val frontTrainer = BattleFrontTrainer(enemyTrainer)
+
+    val scene = BattleScene(this)

src/main/scala/scene/battle/BattleScene.scala

 package Scene.Battle
 
-import Component.*
-import Scene.*
+import Engine.Game
+import Engine.Objects.{GameObject, Scene, Sprite}
 
-import SFML.Graphics.{Font, IntRect, Texture}
+import PlayerMenu.CapacitySelector.CapacitySelectorOverlay
+import PlayerMenu.FightButton
 
-object BattleScene extends Scene:
-    private def healthPercentage(life: Int, maxLife: Int): Int = (48 * (life.toFloat / maxLife.toFloat)).toInt
+import PokemonStatus.{PokemonBackStatus, PokemonFrontStatus}
 
-    def load(game: Main.Game) =
-        val pokemonTrainer = game.trainer.primaryPokemon.get
-        val pokemonTrainerEnemy = game.trainerEnemy.primaryPokemon.get
+import SFML.Graphics.Texture
 
-        val background = Sprite(Texture("src/main/resources/battle/background.png"))
-        background.scale = 4
+class BattleScene(battle: Battle) extends GameObject(scale = 4) with Scene:
+    addComponent[Sprite](Texture("src/main/resources/battle/background.png"), Layer.Background.layer)
+    addComponent[Sprite](Texture("src/main/resources/battle/tiles.png"), Layer.Background.offset(1))
 
-        val tiles = Sprite(Texture("src/main/resources/battle/tiles.png"))
-        tiles.scale = 4
+    addGameObject(battle.backTrainer.sprite)
+    addGameObject(battle.frontTrainer.sprite)
 
-        val bar = Sprite(Texture("src/main/resources/battle/bar.png"))
-        bar.scale = 4
-        bar.pos = (544, 390)
+    addGameObject(battle.frontTrainer.status).moveTo((0, 22))
+    addGameObject(battle.backTrainer.status).moveTo((136, 100))
 
-        val barEnemy = Sprite(Texture("src/main/resources/battle/bar_enemy.png"))
-        barEnemy.scale = 4
-        barEnemy.pos = (0, 90)
+    val capacitySelectorOverlay = addGameObject(CapacitySelectorOverlay(battle)).moveTo((0, -192))
 
-        val healthBar = Sprite(Texture("src/main/resources/battle/health_bar_green.png"))
-        healthBar.scale = 4
-        healthBar.pos = (792, 466)
-        healthBar.rect = Some(healthPercentage(pokemonTrainer.life, pokemonTrainer.maxLife), 7)
-
-        val healthBarEnemy = Sprite(Texture("src/main/resources/battle/health_bar_green.png"))
-        healthBarEnemy.scale = 4
-        healthBarEnemy.pos = (200, 166)
-        healthBarEnemy.rect = Some(healthPercentage(pokemonTrainerEnemy.life, pokemonTrainerEnemy.maxLife), 7)
-
-        val textbox = Sprite(Texture("src/main/resources/textbox.png"))
-        textbox.scale = 4
-        textbox.pos = (0, 576)
-
-        val pokemon = Sprite(Texture(f"src/main/resources/pokemons/back/${pokemonTrainer.id}%03d.png"))
-        pokemon.scale = 4
-        pokemon.pos = (130, 320)
-
-        val pokemonEnemy = Sprite(Texture(f"src/main/resources/pokemons/front/${pokemonTrainerEnemy.id}%03d.png"))
-        pokemonEnemy.scale = 4
-        pokemonEnemy.pos = (645, 150)
-
-        val fightBox = FightBox(Texture("src/main/resources/battle/fight_box.png"))
-        fightBox.scale = 3
-        fightBox.pos = (690, 603)
-
-        val font = Font("src/main/resources/font.ttf")
-
-        val name = Text(font)
-        name.msg = pokemonTrainer.name
-        name.color = 0.toByte
-        name.pos = (624, 415)
-
-        val nameEnemy = Text(font)
-        nameEnemy.msg = pokemonTrainerEnemy.name
-        nameEnemy.color = 0.toByte
-        nameEnemy.pos = (35, 115)
-
-        val health = Text(font)
-        health.msg = s"${pokemonTrainer.life}"
-        health.color = 0.toByte
-        health.pos = (800, 495)
-
-        val maxHealth = Text(font)
-        maxHealth.msg = s"${pokemonTrainer.maxLife}"
-        maxHealth.color = 0.toByte
-        maxHealth.pos = (920, 495)
-
-        val fight = Text(font)
-        fight.msg = "Fight"
-        fight.color = 255.toByte
-        fight.pos = (745, 660)
-
-        this.addComponent(background)
-        this.addComponent(tiles)
-        this.addComponent(bar)
-        this.addComponent(healthBar)
-        this.addComponent(barEnemy)
-        this.addComponent(healthBarEnemy)
-        this.addComponent(textbox)
-        this.addComponent(pokemon)
-        this.addComponent(pokemonEnemy)
-        this.addComponent(fightBox)
-        this.addComponent(name)
-        this.addComponent(nameEnemy)
-        this.addComponent(health)
-        this.addComponent(maxHealth)
-        this.addComponent(fight)
+    val buttonGroup = addGameObject(GameObject(scale = 0.6))
+    buttonGroup.addChild(FightButton(capacitySelectorOverlay)).moveTo((280, 250))

src/main/scala/scene/battle/BattleSceneLayer.scala

+package Scene.Battle
+
+import Engine.Components.RendererLayer
+
+enum Layer(depth: Int):
+    val layer = RendererLayer(depth)
+
+    def offset(offset: Int): RendererLayer =
+        RendererLayer(layer.depth + offset)
+
+    case Background extends Layer(0)
+    case Pokemons extends Layer(10)
+    case UI extends Layer(20)
+    case Overlay extends Layer(30)

src/main/scala/scene/battle/FightBox.scala

-package Scene.Battle
-
-import SFML.Graphics.Texture
-
-import Component.*
-
-class FightBox(texture: Texture) extends Button(78, 46) with DrawableTexture(texture):
-    def onMouseOver(game: Main.Game) = this.color = 200.toByte
-
-    def onMouseClick(game: Main.Game) = game.queryScene = Some(Scene.Battle.CapacitySelector.CapacitySelectorScene)
-
-    def onMouseExit(game: Main.Game) = this.color = 255.toByte

src/main/scala/scene/battle/battleTrainer/BattleBackTrainer.scala

+package Scene.Battle
+package BattleTrainer
+
+import Engine.Objects.{GameObject, Sprite}
+
+import Pokemon.Trainer
+
+import PokemonStatus.{PokemonStatus, PokemonBackStatus}
+
+import SFML.Graphics.Texture
+
+class BattleBackTrainer(trainer: Trainer) extends BattleTrainer(trainer):
+    val sprite: GameObject = GameObject()
+        .moveTo((32, 80))
+        .addComponent[Sprite](
+            Texture(f"src/main/resources/pokemons/back/${pokemon.id}%03d.png"),
+            Layer.Pokemons.layer
+        )
+        .gameObject
+
+    val status: PokemonStatus = PokemonBackStatus(this)
+
+    def takeDamageAnim(): Unit =
+        sprite.translate((-10, 0), 3, callback = () => sprite.translate((10, 0), 3))

src/main/scala/scene/battle/battleTrainer/BattleFrontTrainer.scala

+package Scene.Battle
+package BattleTrainer
+
+import Engine.Objects.{GameObject, Sprite}
+
+import Pokemon.Trainer
+
+import PokemonStatus.{PokemonStatus, PokemonFrontStatus}
+
+import SFML.Graphics.Texture
+
+class BattleFrontTrainer(trainer: Trainer) extends BattleTrainer(trainer):
+    val sprite: GameObject = GameObject()
+        .moveTo((160, 38))
+        .addComponent[Sprite](
+            Texture(f"src/main/resources/pokemons/front/${pokemon.id}%03d.png"),
+            Layer.Pokemons.layer
+        )
+        .gameObject
+
+    val status: PokemonStatus = PokemonFrontStatus(this)
+
+    def takeDamageAnim(): Unit =
+        sprite.translate((10, 0), 3, callback = () => sprite.translate((-10, 0), 3))

src/main/scala/scene/battle/battleTrainer/BattleTrainer.scala

+package Scene.Battle
+package BattleTrainer
+
+import Engine.Objects.GameObject
+
+import Pokemon.{Capacity, Pokemon, Trainer}
+
+import PokemonStatus.PokemonStatus
+
+trait BattleTrainer(val trainer: Trainer):
+    def attack(enemyTrainer: BattleTrainer, capacity: Capacity): Unit =
+        pokemon.useCapacity(capacity, enemyTrainer.pokemon)
+        enemyTrainer.status.healthBar.update()
+        enemyTrainer.takeDamageAnim()
+        println(s"${pokemon.name} attacked ${enemyTrainer.pokemon.name} with ${capacity.name}")
+
+    def pokemon: Pokemon = trainer.primaryPokemon
+
+    val sprite: GameObject
+
+    val status: PokemonStatus
+
+    def takeDamageAnim(): Unit

src/main/scala/scene/battle/capacitySelector/CancelBox.scala

-package Scene.Battle.CapacitySelector
-
-import SFML.Graphics.Texture
-
-import Component.*
-
-class CancelBox(texture: Texture) extends Button(238, 46) with DrawableTexture(texture):
-    def onMouseOver(game: Main.Game) = this.color = 200.toByte
-
-    def onMouseClick(game: Main.Game) = game.queryScene = Some(Scene.Battle.BattleScene)
-
-    def onMouseExit(game: Main.Game) = this.color = 255.toByte

src/main/scala/scene/battle/capacitySelector/CapacityBox.scala

-package Scene.Battle.CapacitySelector
-
-import SFML.Graphics.Texture
-
-import Component.*
-import Pokemon.*
-
-class CapacityBox(texture: Texture, capacity: Capacity) extends Button(124, 55) with DrawableTexture(texture):
-    def onMouseOver(game: Main.Game) = this.color = 200.toByte
-
-    def onMouseClick(game: Main.Game) =
-        game.trainer.primaryPokemon.get.useCapacity(capacity, game.trainerEnemy.primaryPokemon.get)
-        game.queryScene = Some(Scene.Battle.BattleScene)
-        game.isTrainerTurn = false
-
-    def onMouseExit(game: Main.Game) = this.color = 255.toByte

src/main/scala/scene/battle/capacitySelector/CapacitySelectorScene.scala

-package Scene.Battle.CapacitySelector
-
-import Component.*
-import Pokemon.*
-import Scene.*
-
-import SFML.Graphics.{Font, IntRect, Texture}
-
-object CapacitySelectorScene extends Scene:
-    def load(game: Main.Game) =
-        val pokemonTrainer = game.trainer.primaryPokemon.get
-
-        val background = Sprite(Texture("src/main/resources/battle/background_capacities.png"))
-        background.scale = 4
-        this.addComponent(background)
-
-        val capacity_texture = Texture("src/main/resources/battle/capacity.png")
-        val font = Font("src/main/resources/font.ttf")
-
-        if pokemonTrainer.capacity.length >= 1 then
-            val capacity_1 = CapacityBox(capacity_texture, pokemonTrainer.capacity(0))
-            capacity_1.scale = 4
-            capacity_1.pos = (8, 24)
-            this.addComponent(capacity_1)
-
-            val capacity_text_1 = Text(font)
-            capacity_text_1.msg = pokemonTrainer.capacity(0).name
-            capacity_text_1.color = 0.toByte
-            capacity_text_1.pos = (68, 84)
-            this.addComponent(capacity_text_1)
-
-        if pokemonTrainer.capacity.length >= 2 then
-            val capacity_2 = CapacityBox(capacity_texture, pokemonTrainer.capacity(1))
-            capacity_2.scale = 4
-            capacity_2.pos = (520, 24)
-            this.addComponent(capacity_2)
-
-            val capacity_text_2 = Text(font)
-            capacity_text_2.msg = pokemonTrainer.capacity(1).name
-            capacity_text_2.color = 0.toByte
-            capacity_text_2.pos = (580, 84)
-            this.addComponent(capacity_text_2)
-
-        if pokemonTrainer.capacity.length >= 3 then
-            val capacity_3 = CapacityBox(capacity_texture, pokemonTrainer.capacity(2))
-            capacity_3.scale = 4
-            capacity_3.pos = (8, 268)
-            this.addComponent(capacity_3)
-
-            val capacity_text_3 = Text(font)
-            capacity_text_3.msg = pokemonTrainer.capacity(2).name
-            capacity_text_3.color = 0.toByte
-            capacity_text_3.pos = (68, 328)
-            this.addComponent(capacity_text_3)
-
-        if pokemonTrainer.capacity.length >= 4 then
-            val capacity_4 = CapacityBox(capacity_texture, pokemonTrainer.capacity(3))
-            capacity_4.scale = 4
-            capacity_4.pos = (520, 268)
-            this.addComponent(capacity_4)
-
-            val capacity_text_4 = Text(font)
-            capacity_text_4.msg = pokemonTrainer.capacity(3).name
-            capacity_text_4.color = 0.toByte
-            capacity_text_4.pos = (580, 328)
-            this.addComponent(capacity_text_4)
-
-        val cancel = CancelBox(Texture("src/main/resources/battle/cancel_box.png"))
-        cancel.scale = 4
-        cancel.pos = (36, 580)
-
-        val cancel_msg = Text(font)
-        cancel_msg.msg = "Retour au combat"
-        cancel_msg.pos = (300, 660)
-
-        this.addComponent(cancel)
-        this.addComponent(cancel_msg)

src/main/scala/scene/battle/playerMenu/FightButton.scala

+package Scene.Battle
+package PlayerMenu
+
+import Engine.GameEngine
+import Engine.Components.MouseCollider
+import Engine.Objects.{Button, GameObject, Translation}
+
+import SFML.Graphics.{FloatRect, Texture}
+
+class FightButton(overlay: GameObject)
+    extends Button(Texture("src/main/resources/battle/fight_box.png"), Layer.UI.offset(1)):
+    addComponent[FightButtonScript](bounds)
+
+    private class FightButtonScript(bounds: FloatRect) extends MouseCollider(bounds):
+        def onMouseEnter(engine: GameEngine) = ()
+
+        def onMouseClick(engine: GameEngine) = overlay.translate((0, 192), 8)
+
+        def onMouseExit(engine: GameEngine) = ()

src/main/scala/scene/battle/playerMenu/capacitySelector/CancelButton.scala

+package Scene.Battle
+package PlayerMenu
+package CapacitySelector
+
+import Engine.GameEngine
+import Engine.Components.MouseCollider
+import Engine.Objects.{Button, GameObject, Translation}
+
+import SFML.Graphics.{FloatRect, Texture}
+
+class CancelButton extends Button(Texture("src/main/resources/battle/cancel_box.png"), Layer.Overlay.offset(1)):
+    addComponent[CancelButtonScript](bounds)
+
+    private class CancelButtonScript(bounds: FloatRect) extends MouseCollider(bounds):
+        def onMouseEnter(engine: GameEngine) = ()
+
+        def onMouseClick(engine: GameEngine) = gameObject.parent.translate((0, -192), 8)
+
+        def onMouseExit(engine: GameEngine) = ()