Update main after Sprint 2

.mailmap

@@ -0,0 +1,9 @@
+Christopher Budhiawan <xtophb@gmail.com>
+Christopher Budhiawan <christopher.budhiawan@gmail.com>
+Emre Orhan <Emre.Orhan@gmx.at>
+Sofija Sternad-Gugnjak <sofijasternad@outlook.com>
+Alexander Dermutz <adgaming.dev@gmail.com>
+Selina Prettner <prettnerseli@gmail.com>
+Selina Prettner <prettnerseli@gamil.com>
+Anna Pschernig <annpschernig@edu.aau.at>
+Natasa Jeftic <natasajeftic6@gmail.com>

app/src/androidTest/java/com/codenames/frontend/GameboardScreenTest.kt

@@ -0,0 +1,162 @@
+package com.codenames.frontend
+
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import com.codenames.frontend.data.model.ChatDomainModel
+import com.codenames.frontend.data.model.ChatLists
+import com.codenames.frontend.data.model.GameCard
+import com.codenames.frontend.data.model.GameState
+import com.codenames.frontend.data.model.enums.CardType
+import com.codenames.frontend.data.model.enums.ChatTab
+import com.codenames.frontend.ui.roles.PlayerRoles
+import com.codenames.frontend.ui.screens.GameboardScreen
+import org.junit.Rule
+import org.junit.Test
+
+class GameboardScreenTest {
+    @get:Rule
+    val composeRule = createComposeRule()
+
+    @Test
+    fun gameboardDisplaysGameStateFromParameters() {
+        val cards =
+            listOf(
+                GameCard("BERLIN", CardType.BLUE, revealed = false),
+                GameCard("ROME", CardType.RED, revealed = true),
+                GameCard("MOON", CardType.NEUTRAL, revealed = false),
+                GameCard("VIPER", CardType.ASSASSIN, revealed = false),
+            )
+
+        composeRule.setContent {
+            GameboardScreen(
+                userRole = PlayerRoles.BLUE_SPYMASTER,
+                gameState =
+                    GameState(
+                        currentHint = "EAGLE",
+                        currentTurn = PlayerRoles.BLUE_OPERATIVE,
+                        remainingGuesses = 3,
+                        currentBlueFound = 0,
+                        currentRedFound = 1,
+                        cards = cards,
+                    ),
+                onHintChange = { _, _ -> },
+                onReveal = {},
+            )
+        }
+
+        composeRule.onNodeWithText("BERLIN").assertIsDisplayed()
+        composeRule.onNodeWithText("ROME").assertIsDisplayed()
+        composeRule.onNodeWithText("Turn: BLUE_OPERATIVE | Guesses: 3").assertIsDisplayed()
+        composeRule.onNodeWithText("0 FOUND").assertIsDisplayed()
+        composeRule.onNodeWithText("1 FOUND").assertIsDisplayed()
+        composeRule.onAllNodesWithText("Hint: EAGLE").assertCountEquals(0)
+    }
+
+    @Test
+    fun gameboardDisplaysHintForOperative() {
+        composeRule.setContent {
+            GameboardScreen(
+                userRole = PlayerRoles.BLUE_OPERATIVE,
+                gameState =
+                    GameState(
+                        currentHint = "EAGLE",
+                        cards = listOf(GameCard("BERLIN", CardType.BLUE)),
+                    ),
+                onHintChange = { _, _ -> },
+                onReveal = {},
+            )
+        }
+
+        composeRule.onNodeWithText("Hint: EAGLE").assertIsDisplayed()
+    }
+
+    @Test
+    fun spymasterCanOpenLobbyChat() {
+        composeRule.setContent {
+            GameboardScreen(
+                userRole = PlayerRoles.BLUE_SPYMASTER,
+                gameState =
+                    GameState(
+                        currentHint = "EAGLE",
+                        cards = listOf(GameCard("BERLIN", CardType.BLUE)),
+                        chatLists =
+                            ChatLists(
+                                lobbyMessages =
+                                    listOf(
+                                        ChatDomainModel(
+                                            sender = "Anna",
+                                            text = "Lobby message",
+                                            isFromMe = false,
+                                        ),
+                                    ),
+                            ),
+                        availableChatTabs = listOf(ChatTab.GLOBAL),
+                    ),
+                onHintChange = { _, _ -> },
+                onReveal = {},
+            )
+        }
+
+        composeRule.onNodeWithText("Chat").performClick()
+        composeRule.onNodeWithText("Global Chat").assertIsDisplayed()
+        composeRule.onNodeWithText("Anna").assertIsDisplayed()
+        composeRule.onNodeWithText("Lobby message").assertIsDisplayed()
+    }
+
+    @Test
+    fun gameboardDisplaysTeamChatMessages() {
+        composeRule.setContent {
+            GameboardScreen(
+                userRole = PlayerRoles.BLUE_OPERATIVE,
+                gameState =
+                    GameState(
+                        currentHint = "EAGLE",
+                        cards = listOf(GameCard("BERLIN", CardType.BLUE)),
+                        chatLists =
+                            ChatLists(
+                                teamMessages =
+                                    listOf(
+                                        ChatDomainModel(
+                                            sender = "Max",
+                                            text = "Take Berlin",
+                                            isFromMe = false,
+                                        ),
+                                    ),
+                            ),
+                        availableChatTabs = listOf(ChatTab.GLOBAL, ChatTab.TEAM),
+                    ),
+                onHintChange = { _, _ -> },
+                onReveal = {},
+            )
+        }
+
+        composeRule.onNodeWithText("Chat").performClick()
+        composeRule.onNodeWithText("Team").performClick()
+        composeRule.onNodeWithText("Max").assertIsDisplayed()
+        composeRule.onNodeWithText("Take Berlin").assertIsDisplayed()
+    }
+
+    @Test
+    fun operativeChatTabIsHiddenWhenNotAvailable() {
+        composeRule.setContent {
+            GameboardScreen(
+                userRole = PlayerRoles.BLUE_OPERATIVE,
+                gameState =
+                    GameState(
+                        currentHint = "EAGLE",
+                        cards = listOf(GameCard("BERLIN", CardType.BLUE)),
+                        availableChatTabs = listOf(ChatTab.GLOBAL, ChatTab.TEAM),
+                    ),
+                onHintChange = { _, _ -> },
+                onReveal = {},
+            )
+        }
+
+        composeRule.onNodeWithText("Chat").performClick()
+        composeRule.onAllNodesWithText("Operatives").assertCountEquals(0)
+    }
+}

app/src/main/java/com/codenames/frontend/MainActivity.kt

@@ -5,6 +5,8 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.runtime.Composable
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
 import com.codenames.frontend.ui.navigation.NavGraph
 import com.codenames.frontend.ui.theme.CodenamesTheme
 import dagger.hilt.android.AndroidEntryPoint
@@ -14,6 +16,14 @@ class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+
+        WindowInsetsControllerCompat(window, window.decorView).apply {
+            hide(WindowInsetsCompat.Type.systemBars())
+
+            systemBarsBehavior =
+                WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        }
+
         setContent {
             CodenamesTheme {
                 AppContent()

app/src/main/java/com/codenames/frontend/data/model/ChatDomainModel.kt

@@ -0,0 +1,7 @@
+package com.codenames.frontend.data.model
+
+data class ChatDomainModel(
+    val sender: String,
+    val text: String,
+    val isFromMe: Boolean,
+)

app/src/main/java/com/codenames/frontend/data/model/ChatLists.kt

@@ -0,0 +1,7 @@
+package com.codenames.frontend.data.model
+
+data class ChatLists(
+    val lobbyMessages: List<ChatDomainModel> = emptyList(),
+    val teamMessages: List<ChatDomainModel> = emptyList(),
+    val operativeMessages: List<ChatDomainModel> = emptyList(),
+)

app/src/main/java/com/codenames/frontend/data/model/ChatMessage.kt

@@ -0,0 +1,15 @@
+package com.codenames.frontend.data.model
+
+import com.codenames.frontend.data.model.enums.ChatTab
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ChatMessage(
+    val id: Int,
+    val sender: String,
+    val message: String,
+    val timestamp: String,
+    val chatTab: ChatTab,
+    val isSystemMessage: Boolean = false,
+    val isFromMe: Boolean = false,
+)

app/src/main/java/com/codenames/frontend/data/model/ChatUiState.kt

@@ -0,0 +1,6 @@
+package com.codenames.frontend.data.model
+
+data class ChatUiState(
+    val messages: List<ChatMessage> = emptyList(),
+    val currentInput: String = "",
+)

app/src/main/java/com/codenames/frontend/data/model/GameCard.kt

@@ -0,0 +1,9 @@
+package com.codenames.frontend.data.model
+
+import com.codenames.frontend.data.model.enums.CardType
+
+data class GameCard(
+    val word: String,
+    val type: CardType,
+    val revealed: Boolean = false,
+)

app/src/main/java/com/codenames/frontend/data/model/GameState.kt

@@ -0,0 +1,17 @@
+package com.codenames.frontend.data.model
+
+import com.codenames.frontend.data.model.enums.ChatTab
+import com.codenames.frontend.data.model.enums.Team
+import com.codenames.frontend.ui.roles.PlayerRoles
+
+data class GameState(
+    val currentHint: String = "",
+    val cards: List<GameCard> = emptyList(),
+    val currentTurn: PlayerRoles = PlayerRoles.NONE,
+    val winner: Team? = null,
+    val remainingGuesses: Int = 0,
+    val currentRedFound: Int = 0,
+    val currentBlueFound: Int = 0,
+    val chatLists: ChatLists = ChatLists(),
+    val availableChatTabs: List<ChatTab> = listOf(ChatTab.GLOBAL),
+)

app/src/main/java/com/codenames/frontend/data/model/LobbyUiState.kt

@@ -6,4 +6,8 @@ data class LobbyUiState(
     val players: List<Player> = emptyList(),
     val error: String? = null,
     val isGameStarted: Boolean = false,
+    val blueOperatives: List<String> = emptyList(),
+    val blueSpymasters: List<String> = emptyList(),
+    val redOperatives: List<String> = emptyList(),
+    val redSpymasters: List<String> = emptyList(),
 )

app/src/main/java/com/codenames/frontend/data/model/Mapper.kt

@@ -1,12 +1,19 @@
 package com.codenames.frontend.data.model
 
+import com.codenames.frontend.data.model.enums.CardType
+import com.codenames.frontend.data.model.enums.Role
+import com.codenames.frontend.data.model.enums.Team
+import com.codenames.frontend.network.dto.CardDto
+import com.codenames.frontend.network.dto.GameMessage
 import com.codenames.frontend.network.dto.LobbyResponse
 import com.codenames.frontend.network.dto.PlayerDto
+import com.codenames.frontend.ui.roles.PlayerRoles
 
 fun LobbyResponse.toLobbyState(): LobbyUiState =
     LobbyUiState(
         lobbyCode = lobbyCode,
         players = playerList.map { it.toUi() },
+        isGameStarted = isStarted,
     )
 
 fun PlayerDto.toUi(): Player =
@@ -15,5 +22,35 @@ fun PlayerDto.toUi(): Player =
         role = role,
         team = team,
         isHost = isHost,
-        isReady = false, // if we add this functionality
+        isReady = false,
     )
+
+fun GameMessage.toGameState(): GameState {
+    val cards = cardList.map { it.toGameCard() }
+
+    return GameState(
+        currentHint = currentClue?.word ?: "",
+        cards = cards,
+        currentTurn = getCurrentTurn(),
+        winner = winner,
+        remainingGuesses = currentClue?.guessAmount ?: 0,
+        currentRedFound = cards.count { it.type == CardType.RED && it.revealed },
+        currentBlueFound = cards.count { it.type == CardType.BLUE && it.revealed },
+    )
+}
+
+fun CardDto.toGameCard(): GameCard =
+    GameCard(
+        word = word,
+        type = color,
+        revealed = isGuessed,
+    )
+
+fun GameMessage.getCurrentTurn(): PlayerRoles {
+    if (currentTurn == Team.RED) {
+        if (currentPhase == Role.SPYMASTER) return PlayerRoles.RED_SPYMASTER
+        return PlayerRoles.RED_OPERATIVE
+    }
+    if (currentPhase == Role.SPYMASTER) return PlayerRoles.BLUE_SPYMASTER
+    return PlayerRoles.BLUE_OPERATIVE
+}

app/src/main/java/com/codenames/frontend/data/model/SessionState.kt

@@ -0,0 +1,5 @@
+package com.codenames.frontend.data.model
+
+data class SessionState(
+    val username: String,
+)

app/src/main/java/com/codenames/frontend/data/model/enums/CardType.kt

@@ -0,0 +1,8 @@
+package com.codenames.frontend.data.model.enums
+
+enum class CardType {
+    BLUE,
+    RED,
+    NEUTRAL,
+    ASSASSIN,
+}

app/src/main/java/com/codenames/frontend/data/model/enums/ChatMessageType.kt

@@ -0,0 +1,8 @@
+package com.codenames.frontend.data.model.enums
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class ChatMessageType {
+    CHAT,
+}

app/src/main/java/com/codenames/frontend/data/model/enums/ChatTab.kt

@@ -0,0 +1,9 @@
+package com.codenames.frontend.data.model.enums
+
+enum class ChatTab(
+    val title: String,
+) {
+    GLOBAL("Global"),
+    TEAM("Team"),
+    OPERATIVES("Operatives"),
+}

app/src/main/java/com/codenames/frontend/data/model/enums/Role.kt

@@ -1,5 +1,8 @@
 package com.codenames.frontend.data.model.enums
 
+import kotlinx.serialization.Serializable
+
+@Serializable
 enum class Role {
     OPERATIVE,
     SPYMASTER,