Refactor AR Screen to not destroy all pieces' node

mobile/src/androidTest/java/ch/epfl/sdp/mobile/test/ui/game/ar/ChessSceneTest.kt

@@ -1,151 +1,90 @@
 package ch.epfl.sdp.mobile.test.ui.game.ar
 
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.activity.ComponentActivity
 import androidx.lifecycle.lifecycleScope
-import ch.epfl.sdp.mobile.state.HomeActivity
-import ch.epfl.sdp.mobile.ui.game.ChessBoardState
+import androidx.test.ext.junit.rules.ActivityScenarioRule
+import ch.epfl.sdp.mobile.application.chess.engine.Color.*
+import ch.epfl.sdp.mobile.application.chess.engine.Game
+import ch.epfl.sdp.mobile.application.chess.engine.Piece as EnginePiece
+import ch.epfl.sdp.mobile.application.chess.engine.PieceIdentifier
+import ch.epfl.sdp.mobile.application.chess.engine.Rank
+import ch.epfl.sdp.mobile.state.game.delegating.DelegatingChessBoardState.Companion.toPosition
+import ch.epfl.sdp.mobile.state.game.delegating.DelegatingChessBoardState.Piece
+import ch.epfl.sdp.mobile.ui.game.ChessBoardState.*
 import ch.epfl.sdp.mobile.ui.game.ar.ChessScene
-import dev.romainguy.kotlin.math.Float3
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotEquals
+import com.google.common.truth.Truth.assertThat
+import io.github.sceneview.math.Scale
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.yield
 import org.junit.Rule
 import org.junit.Test
 
 class ChessSceneTest {
-  @get:Rule val rule = createAndroidComposeRule<HomeActivity>()
-
-  class SinglePieceSnapshotChessBoardState(
-      private val piece: ChessBoardState.Piece =
-          object : ChessBoardState.Piece {
-            override val color = ChessBoardState.Color.White
-            override val rank = ChessBoardState.Rank.Pawn
-          },
-  ) : ChessBoardState<ChessBoardState.Piece> {
-    var position: ChessBoardState.Position by mutableStateOf(ChessBoardState.Position(0, 0))
-
-    override val pieces: Map<ChessBoardState.Position, ChessBoardState.Piece>
-      get() = mapOf(position to piece)
-    override val checkPosition: ChessBoardState.Position? = null
-    override val lastMove: Set<ChessBoardState.Position> = emptySet()
-  }
 
-  @Test
-  fun given_emptyState_when_initChessScene_then_rootIsNotNull() {
-    val state = SinglePieceSnapshotChessBoardState()
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
+  @get:Rule val rule = ActivityScenarioRule(ComponentActivity::class.java)
 
-    assertNotEquals(null, chessScene.boardNode)
-  }
+  private val simpleBoard =
+      Game.create().board.associate { (pos, piece) -> pos.toPosition() to Piece(piece) }
 
   @Test
-  fun given_chessScene_when_scaled_then_rootHasCorrectScaleVector() {
-    val state = SinglePieceSnapshotChessBoardState()
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-
-    chessScene.scale(4f)
-    assertEquals(Float3(4f), chessScene.boardNode.scale)
+  fun given_emptyState_when_initChessScene_then_has32ChildrenNodes() = runTest {
+    rule.scenario.onActivity {
+      val chessScene = ChessScene(it.applicationContext, it.lifecycleScope, simpleBoard)
+
+      launch {
+        yieldWhile { chessScene.boardNode.children.size != simpleBoard.size }
+        assertThat(chessScene.boardNode.children.size).isEqualTo(simpleBoard.size)
+      }
+    }
   }
 
   @Test
-  fun given_stateWithOneKing_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.Black
-          override val rank = ChessBoardState.Rank.King
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
-  }
+  fun given_chessScene_when_scaled_then_rootHasCorrectScaleVector() = runTest {
+    rule.scenario.onActivity {
+      val chessScene = ChessScene(it.applicationContext, it.lifecycleScope, simpleBoard)
 
-  @Test
-  fun given_stateWithOneBishop_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.Black
-          override val rank = ChessBoardState.Rank.Bishop
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
-  }
+      launch {
+        yieldWhile { chessScene.boardNode.children.size != simpleBoard.size }
 
-  @Test
-  fun given_stateWithOneKnight_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.Black
-          override val rank = ChessBoardState.Rank.Knight
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
+        chessScene.scale(4f)
+        assertThat(chessScene.boardNode.scale).isEqualTo(Scale(4f))
+      }
+    }
   }
 
   @Test
-  fun given_stateWithOnePawn_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.Black
-          override val rank = ChessBoardState.Rank.Pawn
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
-  }
+  fun given_chessScene_whenUpdated_then_haveCorrectNumberOfChildren() = runTest {
+    rule.scenario.onActivity {
+      val chessScene = ChessScene(it.applicationContext, it.lifecycleScope, simpleBoard)
 
-  @Test
-  fun given_stateWithOneQueen_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.Black
-          override val rank = ChessBoardState.Rank.Queen
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
-  }
+      val iterator = simpleBoard.entries.iterator()
+      val oldMovePiece = iterator.next()
+      val newMovePiece = oldMovePiece.apply { (Position(4, 4) to value) }.toPair()
 
-  @Test
-  fun given_stateWithOneRook_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.Black
-          override val rank = ChessBoardState.Rank.Rook
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
-  }
+      val newPiece = (Position(4, 5) to Piece(EnginePiece(White, Rank.Pawn, PieceIdentifier(40))))
+      val newBoard = mapOf(newMovePiece, newPiece)
 
-  @Test
-  fun given_stateWithOneWhitePawn_when_initChessScene_then_rootIsNotNull() {
-    val piece =
-        object : ChessBoardState.Piece {
-          override val color = ChessBoardState.Color.White
-          override val rank = ChessBoardState.Rank.Pawn
-        }
-    val state = SinglePieceSnapshotChessBoardState(piece)
-
-    val chessScene =
-        ChessScene(rule.activity.applicationContext, rule.activity.lifecycleScope, state.pieces)
-    assertNotEquals(null, chessScene.boardNode)
+      launch {
+        yieldWhile { chessScene.boardNode.children.size != simpleBoard.size }
+
+        chessScene.update(newBoard)
+      }
+
+      launch {
+        yieldWhile { chessScene.boardNode.children.size != newBoard.size }
+
+        assertThat(chessScene.boardNode.children.size).isEqualTo(newBoard.size)
+      }
+    }
   }
 }
+
+/**
+ * This function yields until the [predicate] is not satisfied.
+ *
+ * @param predicate if this function returns true yield, otherwise the function ends.
+ */
+private suspend fun yieldWhile(predicate: () -> Boolean) {
+  while (predicate()) yield()
+}

mobile/src/main/java/ch/epfl/sdp/mobile/state/StatefullArScreen.kt

@@ -17,17 +17,11 @@ fun StatefulArScreen(
     modifier: Modifier = Modifier,
 ) {
 
-  val facade = LocalChessFacade.current
+  val chessFacade = LocalChessFacade.current
   val scope = rememberCoroutineScope()
-  val match = remember(facade, id) { facade.match(id) }
+  val match = remember(chessFacade, id) { chessFacade.match(id) }
 
-  val gameScreenState =
-      remember(match, scope) {
-        ActualChessBoardState(
-            match = match,
-            scope = scope,
-        )
-      }
+  val state = remember(match, scope) { ActualChessBoardState(match, scope) }
 
-  ArChessBoardScreen(gameScreenState, modifier)
+  ArChessBoardScreen(state, modifier)
 }

mobile/src/main/java/ch/epfl/sdp/mobile/ui/game/ar/ArChessBoardScreen.kt

@@ -44,14 +44,15 @@ fun <Piece : ChessBoardState.Piece> ArChessBoardScreen(
 
         chessScene =
             ChessScene(context, view.lifecycleScope, state.pieces).apply {
-              // Scale the whole scene to the desired size
-              scale(BoardScale)
-            }
 
-        // Place the chess board on the taped position
-        arSceneView.onTouchAr =
-            { hitResult, _ ->
-              anchorOrMoveBoard(arSceneView, chessScene, hitResult.createAnchor())
+              // Scale the board
+              this.scale(BoardScale)
+
+              // Place the chess board on the tapped position.
+              arSceneView.onTouchAr =
+                  { hitResult, _ ->
+                    anchorOrMoveBoard(arSceneView, chessScene, hitResult.createAnchor())
+                  }
             }
 
         arSceneView