Feature/78 make abilities appear on both clients

chessevolved_model/src/main/kotlin/io/github/chessevolved/components/AbilityTriggerComponent.kt

@@ -8,6 +8,7 @@ class AbilityTriggerComponent(
     // The position of where the trigger happens
     val targetPosition: Position,
     val oldPosition: Position,
+    val isActive: Boolean,
 ) : Component {
     companion object {
         val mapper: ComponentMapper<AbilityTriggerComponent> =

chessevolved_model/src/main/kotlin/io/github/chessevolved/entities/AbilityItemFactory.kt

@@ -24,28 +24,8 @@ class AbilityItemFactory(
         }
 
     fun createAbilityItem(abilityType: AbilityType): Entity {
-        var cooldown: Int = 3
-
-        when (abilityType) {
-            AbilityType.SHIELD -> {
-                cooldown = 3
-            }
-            AbilityType.EXPLOSION -> {
-                cooldown = 2
-            }
-            AbilityType.SWAP -> {
-                cooldown = 2
-            }
-            AbilityType.MIRROR -> {
-                cooldown = 3
-            }
-            AbilityType.NEW_MOVEMENT -> {
-                cooldown = 0
-            }
-        }
-
         return Entity().apply {
-            add(AbilityComponent(abilityType, cooldown, 0))
+            add(AbilityComponent(abilityType, abilityType.cooldownTime, 0))
             add(AbilityCardComponent())
             add(TextureRegionComponent(getAbilityItemTexture(abilityType)))
             engine.addEntity(this)

chessevolved_model/src/main/kotlin/io/github/chessevolved/singletons/EcsEntityMapper.kt

@@ -1,9 +1,12 @@
 package io.github.chessevolved.singletons
 
 import com.badlogic.ashley.core.Engine
+import com.badlogic.ashley.core.Entity
 import com.badlogic.ashley.core.Family
 import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.scenes.scene2d.Stage
+import io.github.chessevolved.components.AbilityComponent
+import io.github.chessevolved.components.AbilityTriggerComponent
 import io.github.chessevolved.components.ActorComponent
 import io.github.chessevolved.components.PieceTypeComponent
 import io.github.chessevolved.components.PlayerColorComponent
@@ -33,20 +36,30 @@ object EcsEntityMapper {
             .get()
 
     fun extractStateFromEngine(engine: Engine): Pair<List<PieceDto>, List<BoardSquareDto>> {
-        val pieces =
-            engine.getEntitiesFor(pieceFamily).map { entity ->
-                val piecePosition = PositionComponent.mapper.get(entity)
+        val pieces: ArrayList<PieceDto> = ArrayList()
 
+        for ((_, value) in Game.getPieceDTOS()) {
+            val pieceDto =
                 PieceDto(
                     position =
                         Position(
-                            piecePosition.position.x,
-                            GameSettings.getBoardSize() - 1 - piecePosition.position.y,
+                            value.position.x,
+                            GameSettings.getBoardSize() - 1 - value.position.y,
                         ),
-                    type = PieceTypeComponent.mapper.get(entity).type,
-                    color = PlayerColorComponent.mapper.get(entity).color,
+                    previousPosition =
+                        Position(
+                            value.previousPosition.x,
+                            GameSettings.getBoardSize() - 1 - value.previousPosition.y,
+                        ),
+                    type = value.type,
+                    color = value.color,
+                    abilityType = value.abilityType,
+                    abilityCurrentCooldown = value.abilityCurrentCooldown,
                 )
-            }
+
+            pieces.add(pieceDto)
+        }
+        var amount = 0
 
         val boardSquares =
             engine.getEntitiesFor(boardSquareFamily).map { entity ->
@@ -87,8 +100,20 @@ object EcsEntityMapper {
                     if (typeComp.type != receivedPiece.type || colorComp.color != receivedPiece.color) {
                         Gdx.app.debug("ECSEntityMapper", "Replacing piece at ${receivedPiece.position} due to type/color mismatch.")
                         engine.removeEntity(existingEntity)
+                        Game.removeEntityFromPieceDTOS(existingEntity)
                         createPieceFromDto(pieceFactory, stage, receivedPiece)
                     }
+
+                    if (receivedPiece.abilityType != null) {
+                        existingEntity.add(
+                            AbilityComponent(
+                                receivedPiece.abilityType!!,
+                                receivedPiece.abilityType!!.cooldownTime,
+                                receivedPiece.abilityCurrentCooldown,
+                            ),
+                        )
+                        existingEntity.add(AbilityTriggerComponent(receivedPiece.position, receivedPiece.position, false))
+                    }
                 } else {
                     Gdx.app.debug("ECSEntityMapper", "Creating new piece: ${receivedPiece.type} at ${receivedPiece.position}")
                     createPieceFromDto(pieceFactory, stage, receivedPiece)
@@ -98,11 +123,14 @@ object EcsEntityMapper {
             for (existingEntity in existingPieceEntities) {
                 val pos = PositionComponent.mapper.get(existingEntity).position
                 if (pos !in currentPositions) {
+                    // Most likely it was this that moved. We can trigger the new entity through movement system.
                     Gdx.app.debug("ECSEntityMapper", "Removing piece no longer in state at $pos")
                     val actorComponent = ActorComponent.mapper.get(existingEntity)
                     actorComponent.actor.remove()
+
+                    Game.removeEntityFromPieceDTOS(existingEntity)
+
                     engine.removeEntity(existingEntity)
-                    println("ActorComp: $actorComponent")
                 }
             }
 
@@ -140,13 +168,28 @@ object EcsEntityMapper {
         stage: Stage,
         pieceData: PieceDto,
     ) {
+        val pieceEntity: Entity
+
         when (pieceData.type) {
-            PieceType.PAWN -> pieceFactory.createPawn(pieceData.position, pieceData.color, stage)
-            PieceType.ROOK -> pieceFactory.createRook(pieceData.position, pieceData.color, stage)
-            PieceType.KNIGHT -> pieceFactory.createKnight(pieceData.position, pieceData.color, stage)
-            PieceType.BISHOP -> pieceFactory.createBishop(pieceData.position, pieceData.color, stage)
-            PieceType.QUEEN -> pieceFactory.createQueen(pieceData.position, pieceData.color, stage)
-            PieceType.KING -> pieceFactory.createKing(pieceData.position, pieceData.color, stage)
+            PieceType.PAWN -> pieceEntity = pieceFactory.createPawn(pieceData.position, pieceData.color, stage)
+            PieceType.ROOK -> pieceEntity = pieceFactory.createRook(pieceData.position, pieceData.color, stage)
+            PieceType.KNIGHT -> pieceEntity = pieceFactory.createKnight(pieceData.position, pieceData.color, stage)
+            PieceType.BISHOP -> pieceEntity = pieceFactory.createBishop(pieceData.position, pieceData.color, stage)
+            PieceType.QUEEN -> pieceEntity = pieceFactory.createQueen(pieceData.position, pieceData.color, stage)
+            PieceType.KING -> pieceEntity = pieceFactory.createKing(pieceData.position, pieceData.color, stage)
+        }
+
+        pieceEntity.apply {
+            if (pieceData.abilityType != null) {
+                add(AbilityComponent(pieceData.abilityType!!, pieceData.abilityType!!.cooldownTime, pieceData.abilityCurrentCooldown))
+                println("CREATEPIECEFROMDTO: THIS ONE GETS TRIGGERED")
+                add(AbilityTriggerComponent(pieceData.position, pieceData.previousPosition, true))
+            }
         }
+
+        println("Ability: ${pieceData.abilityType}")
+        println("AbilityCD: ${pieceData.abilityCurrentCooldown}")
+
+        Game.addPieceDTOS(pieceEntity)
     }
 }

chessevolved_model/src/main/kotlin/io/github/chessevolved/singletons/Game.kt

@@ -1,8 +1,15 @@
 package io.github.chessevolved.singletons
 
+import com.badlogic.ashley.core.Entity
+import io.github.chessevolved.components.AbilityComponent
+import io.github.chessevolved.components.PieceTypeComponent
+import io.github.chessevolved.components.PlayerColorComponent
+import io.github.chessevolved.components.PositionComponent
+import io.github.chessevolved.data.Position
 import io.github.chessevolved.dtos.BoardSquareDto
 import io.github.chessevolved.dtos.GameDto
 import io.github.chessevolved.dtos.PieceDto
+import io.github.chessevolved.enums.AbilityType
 import io.github.chessevolved.enums.PlayerColor
 import io.github.chessevolved.singletons.supabase.SupabaseGameHandler
 import io.github.chessevolved.singletons.supabase.SupabaseLobbyHandler
@@ -12,6 +19,9 @@ object Game {
     private var subscribers = mutableMapOf<String, (updatedGame: GameDto) -> Unit>()
     private var hasAskedForRematch = false
     private var currentTurn: PlayerColor? = null
+    var turnNumber: Int = 0
+
+    private var pieceDTOS: MutableMap<Entity, PieceDto> = mutableMapOf()
 
     suspend fun joinGame(gameId: String) {
         try {
@@ -101,4 +111,54 @@ object Game {
 
         subscribers.remove(subscriberName)
     }
+
+    fun getPieceDTOS(): MutableMap<Entity, PieceDto> {
+        return pieceDTOS
+    }
+
+    fun addPieceDTOS(entity: Entity) {
+        val pieceDTO =
+            PieceDto(
+                position = PositionComponent.mapper.get(entity).position,
+                previousPosition = PositionComponent.mapper.get(entity).position,
+                type = PieceTypeComponent.mapper.get(entity).type,
+                color = PlayerColorComponent.mapper.get(entity).color,
+                abilityType = AbilityComponent.mapper.get(entity)?.ability,
+                abilityCurrentCooldown =
+                    if (AbilityComponent.mapper.get(entity) != null) {
+                        AbilityComponent.mapper.get(
+                            entity,
+                        ).currentAbilityCDTime
+                    } else {
+                        0
+                    },
+            )
+
+        pieceDTOS[entity] = pieceDTO
+    }
+
+    fun changePieceDTOPosition(
+        entity: Entity,
+        targetPosition: Position,
+    ) {
+        if (pieceDTOS.containsKey(entity)) {
+            pieceDTOS[entity]!!.previousPosition = pieceDTOS[entity]!!.position
+            pieceDTOS[entity]!!.position = targetPosition
+        }
+    }
+
+    fun changePieceDTOAbility(
+        entity: Entity,
+        abilityType: AbilityType?,
+        abilityCurrentCooldown: Int,
+    ) {
+        if (pieceDTOS.containsKey(entity)) {
+            pieceDTOS[entity]!!.abilityType = abilityType
+            pieceDTOS[entity]!!.abilityCurrentCooldown = abilityCurrentCooldown
+        }
+    }
+
+    fun removeEntityFromPieceDTOS(entity: Entity) {
+        pieceDTOS.remove(entity)
+    }
 }

chessevolved_model/src/main/kotlin/io/github/chessevolved/singletons/supabase/SupabaseClient.kt

@@ -19,9 +19,12 @@ internal object SupabaseClient {
         }
 
     private val supabase: SupabaseClient =
+        @Suppress("ktlint:standard:max-line-length")
         createSupabaseClient(
-            supabaseUrl = dotenv["SUPABASE_URL"] ?: "no_url_found",
-            supabaseKey = dotenv["SUPABASE_ANON_KEY"] ?: "no_pass_found",
+            supabaseUrl = "https://tsmubattgglbqaarktnw.supabase.co" ?: "no_url_found",
+            supabaseKey =
+                "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InRzbXViYXR0Z2dsYnFhYXJrdG53Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDIwNTE5MzksImV4cCI6MjA1NzYyNzkzOX0.O7DqYVCmuvHa3iOvXl53SOaNu-N6Rfb3E3J1Cg5K4Dw"
+                    ?: "no_pass_found",
         ) {
             install(Postgrest)
             install(Realtime) {

chessevolved_model/src/main/kotlin/io/github/chessevolved/systems/AbilitySystem.kt

@@ -18,6 +18,7 @@ import io.github.chessevolved.enums.AbilityType
 import io.github.chessevolved.enums.VisualEffectSize
 import io.github.chessevolved.enums.VisualEffectType
 import io.github.chessevolved.singletons.EcsEngine
+import io.github.chessevolved.singletons.Game
 
 class AbilitySystem :
     IteratingSystem(
@@ -30,19 +31,29 @@ class AbilitySystem :
         val abilityComponent = AbilityComponent.mapper.get(entity)
         val abilityTriggerComponent = AbilityTriggerComponent.mapper.get(entity)
 
+        println(EcsEngine.getEntitiesFor(Family.all(PieceTypeComponent::class.java, AbilityComponent::class.java).get()))
+
+        println("Triggering ability: ${abilityComponent.ability}")
+        println("Ability CurrentCD: ${abilityComponent.currentAbilityCDTime}")
+
         if (abilityComponent.currentAbilityCDTime <= 0) {
             abilityComponent.currentAbilityCDTime = abilityComponent.abilityCooldownTime
+            Game.changePieceDTOAbility(entity!!, abilityComponent.ability, abilityComponent.currentAbilityCDTime)
         } else {
             abilityComponent.currentAbilityCDTime--
-            entity?.remove(AbilityTriggerComponent::class.java)
+            Game.changePieceDTOAbility(entity!!, abilityComponent.ability, abilityComponent.currentAbilityCDTime)
+            entity.remove(AbilityTriggerComponent::class.java)
             return
         }
 
         when (abilityComponent.ability) {
             AbilityType.EXPLOSION -> {
                 // Since the trigger doesn't know if it was an active call or passive call.
                 // It is the ability's job to determine.
-                if (CapturedComponent.mapper.get(entity) == null) {
+                println("Explosion: isActive? : ${abilityTriggerComponent.isActive}")
+
+                if (abilityTriggerComponent.isActive && CapturedComponent.mapper.get(entity) == null) {
+                    println("Cant enter here?")
                     triggerExplosionEffect(entity, abilityTriggerComponent.targetPosition)
                 }
             }
@@ -54,7 +65,7 @@ class AbilitySystem :
             AbilityType.MIRROR -> {}
         }
 
-        entity?.remove(AbilityTriggerComponent::class.java)
+        entity.remove(AbilityTriggerComponent::class.java)
     }
 
     private fun triggerExplosionEffect(
@@ -119,10 +130,12 @@ class AbilitySystem :
             EcsEngine.addEntity(effectEntity)
         } else if (shieldEffectEntity != null) {
             abilityComponent.currentAbilityCDTime = 0
+            Game.changePieceDTOAbility(entity!!, abilityComponent.ability, abilityComponent.currentAbilityCDTime)
             PositionComponent.mapper.get(shieldEffectEntity).position = targetPosition
         } else {
             abilityComponent.currentAbilityCDTime = 0
-            entity?.add(BlockedComponent())
+            Game.changePieceDTOAbility(entity!!, abilityComponent.ability, abilityComponent.currentAbilityCDTime)
+            entity.add(BlockedComponent())
 
             val effectEntity = EcsEngine.createEntity()
             effectEntity.add(VisualEffectComponent(VisualEffectType.SHIELD_ACTIVE, 3, duration = 0f, squareSize = VisualEffectSize.NORMAL))

chessevolved_model/src/main/kotlin/io/github/chessevolved/systems/CaptureSystem.kt

@@ -14,6 +14,7 @@ import io.github.chessevolved.components.PositionComponent
 import io.github.chessevolved.components.SelectionComponent
 import io.github.chessevolved.components.ValidMovesComponent
 import io.github.chessevolved.singletons.EcsEngine
+import io.github.chessevolved.singletons.Game
 
 class CaptureSystem : IteratingSystem(
     Family.all(CapturedComponent::class.java).get(),
@@ -38,9 +39,7 @@ class CaptureSystem : IteratingSystem(
         }
 
         if (capturedBlockedComponent != null) {
-            // Trigger the ability.
-            entity?.add(AbilityTriggerComponent(capturedPosition, capturedPosition))
-            // entity?.remove(CapturedComponent::class.java)
+            entity?.add(AbilityTriggerComponent(capturedPosition, capturedPosition, false))
             capturingPiece?.remove(SelectionComponent::class.java)
             capturingPiece?.remove(ValidMovesComponent::class.java)
             return
@@ -56,6 +55,8 @@ class CaptureSystem : IteratingSystem(
         val actor = ActorComponent.mapper.get(entity).actor
         actor.remove()
 
+        Game.removeEntityFromPieceDTOS(entity!!)
+
         EcsEngine.removeEntity(entity)
     }
 }

chessevolved_model/src/main/kotlin/io/github/chessevolved/systems/InputSystem.kt

@@ -10,6 +10,7 @@ import io.github.chessevolved.components.CapturedComponent
 import io.github.chessevolved.components.ClickEventComponent
 import io.github.chessevolved.components.MovementIntentComponent
 import io.github.chessevolved.components.PieceTypeComponent
+import io.github.chessevolved.components.PlayerColorComponent
 import io.github.chessevolved.components.PositionComponent
 import io.github.chessevolved.components.SelectionComponent
 import io.github.chessevolved.components.WeatherEventComponent
@@ -49,7 +50,8 @@ class InputSystem :
         } else {
             if (selectedEntity != null &&
                 AbilityCardComponent.mapper.get(selectedEntity) != null &&
-                AbilityCardComponent.mapper.get(selectedEntity).isInInventory
+                AbilityCardComponent.mapper.get(selectedEntity).isInInventory &&
+                PlayerColorComponent.mapper.get(piece).color == GameSettings.clientPlayerColor
             ) {
                 if (AbilityComponent.mapper.get(piece) != null) {
                     println("Already has ability")
@@ -66,7 +68,9 @@ class InputSystem :
                         )
                     }
 
-                    println("Ability got applied to piece!")
+                    Game.changePieceDTOAbility(piece, abilityComponent.ability, abilityComponent.currentAbilityCDTime)
+                    print("Ability got applied to piece!")
+                    print(" For position: ${PositionComponent.mapper.get(piece).position}\n")
                     selectedEntity.removeAll() // Remove abilityCard-entity from the game.
                 }
             } else {