Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • v-lafeychine/prog-2
1 result
Show changes
Showing
with 239 additions and 233 deletions
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
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)
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)
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()
...@@ -5,8 +5,8 @@ class Trainer(val name: String, var listPokemon: List[Pokemon], var indexPrimary ...@@ -5,8 +5,8 @@ class Trainer(val name: String, var listPokemon: List[Pokemon], var indexPrimary
def numberPokemon: Int = def numberPokemon: Int =
this.listPokemon.length this.listPokemon.length
def primaryPokemon: Option[Pokemon] = def primaryPokemon: Pokemon =
this.listPokemon.lift(this.indexPrimaryPokemon) this.listPokemon.lift(this.indexPrimaryPokemon).get
def changePrimaryPokemon(index: Int): Unit = def changePrimaryPokemon(index: Int): Unit =
assert(0 <= index && index < this.numberPokemon, "This Pokemon doesn't exists.") assert(0 <= index && index < this.numberPokemon, "This Pokemon doesn't exists.")
......
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
package Scene
import Component.*
import SFML.Graphics.Texture
class Sprite(texture: Texture) extends DrawableTexture(texture):
def init() = ()
def update(game: Main.Game) = ()
package Scene
import Component.*
import SFML.Graphics.Font
class Text(font: Font) extends DrawableText(font):
def init() = ()
def update(game: Main.Game) = ()
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)
package Scene.Battle package Scene.Battle
import Component.* import Engine.Game
import Scene.* import Engine.Objects.{GameObject, Scene, Sprite}
import SFML.Graphics.{Font, IntRect, Texture} import PlayerMenu.CapacitySelector.CapacitySelectorOverlay
import PlayerMenu.FightButton
object BattleScene extends Scene: import PokemonStatus.{PokemonBackStatus, PokemonFrontStatus}
private def healthPercentage(life: Int, maxLife: Int): Int = (48 * (life.toFloat / maxLife.toFloat)).toInt
def load(game: Main.Game) = import SFML.Graphics.Texture
val pokemonTrainer = game.trainer.primaryPokemon.get
val pokemonTrainerEnemy = game.trainerEnemy.primaryPokemon.get
val background = Sprite(Texture("src/main/resources/battle/background.png")) class BattleScene(battle: Battle) extends GameObject(scale = 4) with Scene:
background.scale = 4 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")) addGameObject(battle.backTrainer.sprite)
tiles.scale = 4 addGameObject(battle.frontTrainer.sprite)
val bar = Sprite(Texture("src/main/resources/battle/bar.png")) addGameObject(battle.frontTrainer.status).moveTo((0, 22))
bar.scale = 4 addGameObject(battle.backTrainer.status).moveTo((136, 100))
bar.pos = (544, 390)
val barEnemy = Sprite(Texture("src/main/resources/battle/bar_enemy.png")) val capacitySelectorOverlay = addGameObject(CapacitySelectorOverlay(battle)).moveTo((0, -192))
barEnemy.scale = 4
barEnemy.pos = (0, 90)
val healthBar = Sprite(Texture("src/main/resources/battle/health_bar_green.png")) val buttonGroup = addGameObject(GameObject(scale = 0.6))
healthBar.scale = 4 buttonGroup.addChild(FightButton(capacitySelectorOverlay)).moveTo((280, 250))
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)
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)
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
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))
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))
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
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
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
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)
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) = ()
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) = ()