Dev

backend/src/main/scala/model/SimulationState.scala

@@ -35,7 +35,8 @@ case class SimulationState(
     games: List[Game],
     spawner: Option[Spawner],
     walls: List[Wall],
-    ticker: Ticker = Ticker(60.0)
+    ticker: Ticker = Ticker(60.0),
+    frameRate: Double = 60.0
 )
 
 /** Factory and utility object for creating SimulationState instances.
@@ -275,3 +276,15 @@ extension (state: SimulationState)
     */
   def addWall(wall: Wall): SimulationState =
     state.copy(walls = wall :: state.walls)
+
+  /** Creates a new SimulationState with an updated framerate.
+    *
+    * Ticker is updated according to framerate
+    *
+    * @param frameRate
+    *   the new framerate
+    * @return
+    *   new SimulationState with the new framerate
+    */
+  def updateFrameRate(frameRate: Double): SimulationState =
+    state.copy(frameRate = frameRate, ticker = Ticker(frameRate))

backend/src/main/scala/model/entities/Player.scala

@@ -9,3 +9,7 @@ trait Player[T <: Player[T]] extends Movable[T] with Entity:
   def isPlaying: Boolean
   def play(game: Game): T
   def stopPlaying: T
+
+trait ChangingFavouriteGamePlayer[T <: ChangingFavouriteGamePlayer[T]]
+    extends Player[T]:
+  def withFavouriteGame(gameType: GameType): T

backend/src/main/scala/model/entities/customers/Bankroll.scala

@@ -16,4 +16,6 @@ trait Bankroll[T <: Bankroll[T]]:
     )
     withBankroll(newBankroll, true)
 
+  def bankrollRatio: Double = bankroll / startingBankroll
+
   def withBankroll(newBankroll: Double, update: Boolean = false): T

backend/src/main/scala/model/entities/customers/Customer.scala

@@ -3,8 +3,8 @@ package model.entities.customers
 import scala.util.Random
 
 import model.SimulationState
+import model.entities.ChangingFavouriteGamePlayer
 import model.entities.Entity
-import model.entities.Player
 import model.entities.customers.CustState.Idle
 import model.entities.customers.CustState.Playing
 import model.entities.customers.RiskProfile.Regular
@@ -18,6 +18,7 @@ import model.managers.movements.Boids._
 import model.managers.movements.PlayerManagers
 import model.managers.movements.PlayerManagers.GamesAttractivenessManager
 import model.managers.movements.PlayerManagers.PlayerSitterManager
+import model.managers.movements.RandomMovementManager
 import model.managers.|
 import utils.Vector2D
 
@@ -43,13 +44,13 @@ case class Customer(
       StatusProfile,
       CustomerState[Customer],
       HasBetStrategy[Customer],
-      Player[Customer]:
+      ChangingFavouriteGamePlayer[Customer]:
 
   def withId(newId: String): Customer =
     this.copy(id = newId)
 
   def withPosition(newPosition: Vector2D): Customer =
-    this.copy(position = newPosition, previousPosition = Some(position))
+    this.copy(position = newPosition)
 
   def withBankroll(newRoll: Double, update: Boolean = false): Customer =
     if update then this.copy(bankroll = newRoll)
@@ -62,7 +63,12 @@ case class Customer(
     this.copy(frustration = newFrustration)
 
   def withCustomerState(newState: CustState): Customer =
-    this.copy(customerState = newState)
+    this.copy(
+      customerState = newState,
+      previousPosition = newState match
+        case Playing(_) => Some(position)
+        case _          => None
+    )
 
   def withDirection(newDirection: Vector2D): Customer =
     this.copy(direction = newDirection)
@@ -100,6 +106,9 @@ case class Customer(
     case Playing(_) => true
     case _          => false
 
+  override def withFavouriteGame(gameType: GameType): Customer =
+    copy(favouriteGame = gameType)
+
 /** This manager implements the default behaviour for the customer. It combines
   * the boid-like behaviours, the games' attractiveness and avoids the
   * collisions of customers with walls and games
@@ -113,25 +122,29 @@ case class DefaultMovementManager(
     separationWeight: Double = 1.0,
     gamesAttractivenessWeight: Double = 1.0,
     sittingRadius: Double = 100,
-    boredomIncrease: Double = 0.1
+    boredomIncrease: Double = 0.1,
+    randomMovementWeight: Double = 0
 ) extends BaseManager[SimulationState]:
 
   override def update(slice: SimulationState): SimulationState =
     slice | FilterManager(
-      GamesAttractivenessAdapter(
-        gamesAttractivenessWeight * GamesAttractivenessManager(boredomIncrease)
-          | PlayerSitterManager(sittingRadius)
+      BoidsAdapter(
+        PerceptionLimiterManager(perceptionRadius)
+          | alignmentWeight * AlignmentManager()
+          | cohesionWeight * CohesionManager()
+          | separationWeight * SeparationManager(avoidRadius)
+          | VelocityLimiterManager(maxSpeed)
       )
-        | BoidsAdapter(
-          PerceptionLimiterManager(perceptionRadius)
-            | alignmentWeight * AlignmentManager()
-            | cohesionWeight * CohesionManager()
-            | separationWeight * SeparationManager(avoidRadius)
-            | VelocityLimiterManager(maxSpeed)
+        | SingleCustomerAdapter(randomMovementWeight * RandomMovementManager())
+        | GamesAttractivenessAdapter(
+          gamesAttractivenessWeight * GamesAttractivenessManager(
+            boredomIncrease
+          )
+            | PlayerSitterManager(sittingRadius)
         )
     )
       | WallAvoidingAdapter(AvoidObstaclesManager())
-      | BoidsAdapter(MoverManager())
+      | SingleCustomerAdapter(MoverManager())
 
 /** This manager adapts the `manager` which updates players contexts to one
   * which manipulates `SimulationState`. The contexts are updated one-by-one,
@@ -216,3 +229,15 @@ private case class FilterManager(manager: BaseManager[SimulationState])
       games =
         slice.games.map(g => updatedState.games.find(_.id == g.id).getOrElse(g))
     )
+
+/** This manager adapts a base manager that handles a single customer to accept
+  * a simulation state
+  * @param manager
+  *   the adapted manager
+  */
+private case class SingleCustomerAdapter(manager: BaseManager[Customer])
+    extends BaseManager[SimulationState]:
+  override def update(slice: SimulationState): SimulationState =
+    slice.copy(
+      customers = slice.customers.map(_ | manager)
+    )

backend/src/main/scala/model/entities/games/Game.scala

@@ -25,6 +25,9 @@ object Roulette extends GameType
 /** Game type representing blackjack games */
 object Blackjack extends GameType
 
+/** Game's types present in the current implementation */
+val gameTypesPresent: Seq[GameType] = Seq(SlotMachine, Roulette, Blackjack)
+
 /** Abstract base trait for all casino games in the simulation.
   *
   * Represents a game entity that can be positioned in 2D space, maintains

backend/src/main/scala/model/entities/spawner/Spawner.scala

@@ -66,12 +66,17 @@ case class Spawner(
     else state
 
   private def defaultCustomerCreation(): Customer =
-    val br = Random.between(50, 10000)
-    val p = br match
-      case b if b < 100   => Casual
-      case b if b < 1500  => Regular
-      case b if b < 5000  => Impulsive
-      case b if b < 10000 => VIP
+    val pNumber = Random.between(1, 5)
+    val p = pNumber match
+      case 1 => Casual
+      case 2 => Regular
+      case 3 => Impulsive
+      case 4 => VIP
+    val br = p match
+      case Casual    => Random.between(50, 151)
+      case Regular   => Random.between(200, 1501)
+      case VIP       => Random.between(3000, 8001)
+      case Impulsive => Random.between(1500, 5001)
     val fg = Random
       .shuffle(
         Seq(
@@ -84,7 +89,7 @@ case class Spawner(
     val bs = fg match
       case Roulette    => MartingaleStrat[Customer](br * 0.02, defaultRedBet)
       case Blackjack   => MartingaleStrat[Customer](br * 0.02, defaultRedBet)
-      case SlotMachine => FlatBetting[Customer](br * 0.04)
+      case SlotMachine => FlatBetting[Customer](br * 0.05, defaultRedBet)
 
     Customer()
       .withPosition(this.position.around(5.0))

backend/src/main/scala/model/entities/spawner/SpawningStrategy.scala

@@ -8,6 +8,8 @@ package model.entities.spawner
   * step functions.
   */
 trait SpawningStrategy:
+  protected def hourPerDay: Double = 24.0
+
   /** Calculates the number of customers to spawn at the given time.
     *
     * @param time
@@ -51,10 +53,11 @@ case class GaussianStrategy(
     base: Int = 0
 ) extends SpawningStrategy:
   override def customersAt(time: Double): Int =
+    val dayTime = time % hourPerDay
     if (stdDev <= 0) {
-      if (math.abs(time - mean) < 1e-9) (base + peak).toInt else base
+      if (math.abs(dayTime - mean) < 1e-9) (base + peak).toInt else base
     } else {
-      val exponent = -0.5 * math.pow((time - mean) / stdDev, 2)
+      val exponent = -0.5 * math.pow((dayTime - mean) / stdDev, 2)
       val value = base + peak * math.exp(exponent)
       math.round(value).toInt.max(0)
     }
@@ -83,9 +86,10 @@ case class StepStrategy(
     endTime: Double
 ) extends SpawningStrategy:
   override def customersAt(time: Double): Int =
-    if (startTime > endTime) then
-      if (time <= endTime || time >= startTime) then highRate else lowRate
-    else if (time >= startTime && time <= endTime) then highRate
+    val dayTime = time % hourPerDay
+    if startTime > endTime then
+      if dayTime <= endTime || dayTime >= startTime then highRate else lowRate
+    else if dayTime >= startTime && dayTime <= endTime then highRate
     else lowRate
 
 /** Builder class for constructing and composing spawning strategies using a