feat(websocket)!: Implement WebSocket connection and event handling (#82)

Co-authored-by: LQ63 <lkhermann@web.de>
Reviewed-on: #82
Co-authored-by: Janis <janis.e.20@gmx.de>
Co-committed-by: Janis <janis.e.20@gmx.de>

knockoutwhistweb/app/controllers/IngameController.scala

@@ -1,7 +1,7 @@
 package controllers
 
 import auth.{AuthAction, AuthenticatedRequest}
-import de.knockoutwhist.control.GameState.{FinishedMatch, InGame, Lobby, SelectTrump, TieBreak}
+import de.knockoutwhist.control.GameState.*
 import exceptions.*
 import logic.PodManager
 import logic.game.GameLobby
@@ -18,12 +18,28 @@ import scala.concurrent.ExecutionContext
 import scala.util.Try
 
 @Singleton
-class IngameController @Inject() (
-                                   val cc: ControllerComponents,
-                                   val podManager: PodManager,
-                                   val authAction: AuthAction,
-                                   implicit val ec: ExecutionContext
-                                 ) extends AbstractController(cc) {
+class IngameController @Inject()(
+                                  val cc: ControllerComponents,
+                                  val authAction: AuthAction,
+                                  implicit val ec: ExecutionContext
+                                ) extends AbstractController(cc) {
+
+  def game(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+    val game = PodManager.getGame(gameId)
+    game match {
+      case Some(g) =>
+        val results = Try {
+          returnInnerHTML(g, request.user)
+        }
+        if (results.isSuccess) {
+          Ok(views.html.main("In-Game - Knockout Whist")(results.get))
+        } else {
+          InternalServerError(results.failed.get.getMessage)
+        }
+      case None =>
+        Redirect(routes.MainMenuController.mainMenu())
+    }
+  }
 
   def returnInnerHTML(gameLobby: GameLobby, user: User): Html = {
     gameLobby.logic.getCurrentState match {
@@ -34,10 +50,10 @@ class IngameController @Inject() (
           gameLobby
         )
       case SelectTrump =>
-          views.html.ingame.selecttrump(
-            gameLobby.getPlayerByUser(user),
-            gameLobby
-          )
+        views.html.ingame.selecttrump(
+          gameLobby.getPlayerByUser(user),
+          gameLobby
+        )
       case TieBreak =>
         views.html.ingame.tie(
           gameLobby.getPlayerByUser(user),
@@ -53,24 +69,8 @@ class IngameController @Inject() (
     }
   }
 
-  def game(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
-    game match {
-      case Some(g) =>
-        val results = Try {
-          returnInnerHTML(g, request.user)
-        }
-        if (results.isSuccess) {
-          Ok(views.html.main("In-Game - Knockout Whist")(results.get))
-        } else {
-          InternalServerError(results.failed.get.getMessage)
-        }
-      case None =>
-        Redirect(routes.MainMenuController.mainMenu())
-    }
-  }
   def startGame(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     val result = Try {
       game match {
         case Some(g) =>
@@ -111,13 +111,14 @@ class IngameController @Inject() (
       }
     }
   }
+
   def kickPlayer(gameId: String, playerToKick: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     val playerToKickUUID = UUID.fromString(playerToKick)
     val result = Try {
       game.get.leaveGame(playerToKickUUID)
     }
-    if(result.isSuccess) {
+    if (result.isSuccess) {
       Ok(Json.obj(
         "status" -> "success",
         "redirectUrl" -> routes.IngameController.game(gameId).url
@@ -129,15 +130,17 @@ class IngameController @Inject() (
       ))
     }
   }
+
   def leaveGame(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     val result = Try {
       game.get.leaveGame(request.user.id)
     }
     if (result.isSuccess) {
       Ok(Json.obj(
         "status" -> "success",
-        "redirectUrl" -> routes.MainMenuController.mainMenu().url
+        "redirectUrl" -> routes.MainMenuController.mainMenu().url,
+        "content" -> views.html.mainmenu.creategame(Some(request.user)).toString
       ))
     } else {
       InternalServerError(Json.obj(
@@ -146,9 +149,9 @@ class IngameController @Inject() (
       ))
     }
   }
-  
+
   def playCard(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] => {
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     game match {
       case Some(g) =>
         val jsonBody = request.body.asJson
@@ -218,8 +221,9 @@ class IngameController @Inject() (
     }
   }
   }
+
   def playDogCard(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] => {
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     game match {
       case Some(g) => {
         val jsonBody = request.body.asJson
@@ -282,8 +286,9 @@ class IngameController @Inject() (
     }
   }
   }
+
   def playTrump(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     game match {
       case Some(g) =>
         val jsonBody = request.body.asJson
@@ -334,8 +339,9 @@ class IngameController @Inject() (
         NotFound("Game not found")
     }
   }
+
   def playTie(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     game match {
       case Some(g) =>
         val jsonBody = request.body.asJson
@@ -386,10 +392,10 @@ class IngameController @Inject() (
         NotFound("Game not found")
     }
   }
-  
-  
+
+
   def returnToLobby(gameId: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
-    val game = podManager.getGame(gameId)
+    val game = PodManager.getGame(gameId)
     game match {
       case Some(g) =>
         val result = Try {

knockoutwhistweb/app/controllers/JavaScriptRoutingController.scala

@@ -1,35 +1,24 @@
 package controllers
 
-import auth.{AuthAction, AuthenticatedRequest}
-import logic.PodManager
+import auth.AuthAction
 import play.api.mvc.{Action, AnyContent, BaseController, ControllerComponents}
 import play.api.routing.JavaScriptReverseRouter
 
 import javax.inject.Inject
 
-class JavaScriptRoutingController  @Inject()(
-                                              val controllerComponents: ControllerComponents,
-                                              val authAction: AuthAction,
-                                              val podManager: PodManager
-                                            ) extends BaseController {
+class JavaScriptRoutingController @Inject()(
+                                             val controllerComponents: ControllerComponents,
+                                             val authAction: AuthAction,
+                                           ) extends BaseController {
   def javascriptRoutes(): Action[AnyContent] =
     Action { implicit request =>
-    Ok(
-      JavaScriptReverseRouter("jsRoutes")(
+      Ok(
+        JavaScriptReverseRouter("jsRoutes")(
           routes.javascript.MainMenuController.createGame,
           routes.javascript.MainMenuController.joinGame,
           routes.javascript.MainMenuController.navSPA,
-          routes.javascript.IngameController.startGame,
-          routes.javascript.IngameController.kickPlayer,
-          routes.javascript.IngameController.leaveGame,
-          routes.javascript.IngameController.playCard,
-          routes.javascript.IngameController.playDogCard,
-          routes.javascript.IngameController.playTrump,
-          routes.javascript.IngameController.playTie,
-          routes.javascript.IngameController.returnToLobby,
-          routes.javascript.PollingController.polling,
           routes.javascript.UserController.login_Post
-      )
-    ).as("text/javascript")
-  }
+        )
+      ).as("text/javascript")
+    }
 }

knockoutwhistweb/app/controllers/MainMenuController.scala

@@ -17,7 +17,6 @@ import javax.inject.*
 class MainMenuController @Inject()(
                                     val controllerComponents: ControllerComponents,
                                     val authAction: AuthAction,
-                                    val podManager: PodManager,
                                     val ingameController: IngameController
                                   ) extends BaseController {
 
@@ -39,7 +38,7 @@ class MainMenuController @Inject()(
       val playeramount: String = (jsonBody.get \ "playeramount").asOpt[String]
         .getOrElse(throw new IllegalArgumentException("Player amount is required."))
 
-      val gameLobby = podManager.createGame(
+      val gameLobby = PodManager.createGame(
         host = request.user,
         name = gamename,
         maxPlayers = playeramount.toInt
@@ -55,16 +54,16 @@ class MainMenuController @Inject()(
         "errorMessage" -> "Invalid form submission"
       ))
     }
-    
+
   }
-  
+
   def joinGame(): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
     val jsonBody = request.body.asJson
     val gameId: Option[String] = jsonBody.flatMap { jsValue =>
       (jsValue \ "gameId").asOpt[String]
     }
     if (gameId.isDefined) {
-      val game = podManager.getGame(gameId.get)
+      val game = PodManager.getGame(gameId.get)
       game match {
         case Some(g) =>
           g.addUser(request.user)
@@ -91,7 +90,7 @@ class MainMenuController @Inject()(
     Ok(views.html.main("Knockout Whist - Rules")(views.html.mainmenu.rules(Some(request.user))))
   }
 
-  def navSPA(location: String) : Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+  def navSPA(location: String): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
     location match {
       case "0" => // Main Menu
         Ok(Json.obj(

knockoutwhistweb/app/controllers/PollingController.scala

@@ -1,153 +0,0 @@
-package controllers
-
-import auth.{AuthAction, AuthenticatedRequest}
-import controllers.PollingController.{scheduler, timeoutDuration}
-import de.knockoutwhist.cards.Hand
-import de.knockoutwhist.player.AbstractPlayer
-import logic.PodManager
-import logic.game.{GameLobby, PollingEvents}
-import logic.game.PollingEvents.{CardPlayed, LobbyCreation, LobbyUpdate, NewRound, NewTrick, ReloadEvent}
-import model.sessions.UserSession
-import model.users.User
-import play.api.libs.json.{JsArray, JsValue, Json}
-import play.api.mvc.{AbstractController, Action, AnyContent, ControllerComponents, Result}
-import util.WebUIUtils
-
-import javax.inject.{Inject, Singleton}
-import scala.concurrent.{ExecutionContext, Future}
-import java.util.concurrent.{Executors, ScheduledExecutorService, TimeUnit}
-import scala.concurrent.duration.*
-object PollingController {
-  private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor()
-  private val timeoutDuration = 25.seconds
-}
-@Singleton
-class PollingController @Inject() (
-                                    val cc: ControllerComponents,
-                                    val podManager: PodManager,
-                                    val authAction: AuthAction,
-                                    val ingameController: IngameController,
-                                    implicit val ec: ExecutionContext
-                                  ) extends AbstractController(cc) {
-
-  private def buildCardPlayResponse(game: GameLobby, hand: Option[Hand], player: AbstractPlayer, newRound: Boolean): JsValue = {
-    val currentRound = game.logic.getCurrentRound.get
-    val currentTrick = game.logic.getCurrentTrick.get
-
-    val trickCardsJson = Json.toJson(
-      currentTrick.cards.map { case (card, player) =>
-        Json.obj("cardId" -> WebUIUtils.cardtoString(card), "player" -> player.name)
-      }
-    )
-    val scoreTableJson = Json.toJson(
-      game.getLogic.getPlayerQueue.get.toList.map { player =>
-        Json.obj(
-          "name" -> player.name,
-          "tricks" -> currentRound.tricklist.count(_.winner.contains(player))
-        )
-      }
-    )
-
-    val stringHand = hand.map { h =>
-      val cardStrings = h.cards.map(WebUIUtils.cardtoString)
-      Json.toJson(cardStrings).as[JsArray]
-    }.getOrElse(Json.arr())
-
-    val firstCardId = currentTrick.firstCard.map(WebUIUtils.cardtoString).getOrElse("BLANK")
-    val nextPlayer = game.getLogic.getPlayerQueue.get.duplicate().nextPlayer().name
-    Json.obj(
-      "status" -> "cardPlayed",
-      "animation" -> newRound,
-      "handData" -> stringHand,
-      "dog" -> player.isInDogLife,
-      "currentPlayerName" -> game.logic.getCurrentPlayer.get.name,
-      "trumpSuit" -> currentRound.trumpSuit.toString,
-      "trickCards" -> trickCardsJson,
-      "scoreTable" -> scoreTableJson,
-      "firstCardId" -> firstCardId,
-      "nextPlayer" -> nextPlayer,
-      "yourTurn" -> (game.logic.getCurrentPlayer.get == player)
-    )
-  }
-
-  private def buildLobbyUsersResponse(game: GameLobby, userSession: UserSession): JsValue = {
-    Json.obj(
-      "status" -> "lobbyUpdate",
-      "host" ->  userSession.host,
-      "users" -> game.getUsers.map(u => Json.obj(
-        "name" -> u.name,
-        "id" -> u.id,
-        "self" -> (u.id == userSession.id)
-      )),
-      "maxPlayers" -> game.maxPlayers
-    )
-  }
-
-
-  def handleEvent(event: PollingEvents, game: GameLobby, userSession: UserSession): Result = {
-    event match {
-      case NewRound =>
-        val player = game.getPlayerByUser(userSession.user)
-        val hand = player.currentHand()
-        val jsonResponse = buildCardPlayResponse(game, hand, player, true)
-        Ok(jsonResponse)
-      case NewTrick =>
-        val player = game.getPlayerByUser(userSession.user)
-        val hand = player.currentHand()
-        val jsonResponse = buildCardPlayResponse(game, hand, player, false)
-        Ok(jsonResponse)
-      case CardPlayed =>
-        val player = game.getPlayerByUser(userSession.user)
-        val hand = player.currentHand()
-        val jsonResponse = buildCardPlayResponse(game, hand, player, false)
-        Ok(jsonResponse)
-      case LobbyUpdate =>
-        Ok(buildLobbyUsersResponse(game, userSession))
-      case ReloadEvent =>
-        val jsonResponse = Json.obj(
-          "status" -> "reloadEvent",
-          "redirectUrl" -> routes.IngameController.game(game.id).url,
-          "content" -> ingameController.returnInnerHTML(game, userSession.user).toString
-        )
-        Ok(jsonResponse)
-    }
-  }
-
-  def polling(gameId: String): Action[AnyContent] = authAction.async { implicit request: AuthenticatedRequest[AnyContent] =>
-
-    val playerId = request.user.id
-
-    podManager.getGame(gameId) match {
-      case Some(game) =>
-        val playerEventQueue = game.getEventsOfPlayer(playerId)
-        if (playerEventQueue.nonEmpty) {
-          val event = playerEventQueue.dequeue()
-          Future.successful(handleEvent(event, game, game.getUserSession(playerId)))
-        } else {
-          val eventPromise = game.registerWaiter(playerId)
-          val scheduledFuture = scheduler.schedule(
-            new Runnable {
-              override def run(): Unit =
-                eventPromise.tryFailure(new java.util.concurrent.TimeoutException("Polling Timeout"))
-            },
-            timeoutDuration.toMillis,
-            TimeUnit.MILLISECONDS
-          )
-          eventPromise.future.map { event =>
-            scheduledFuture.cancel(false)
-            game.removeWaiter(playerId)
-            handleEvent(event, game, game.getUserSession(playerId))
-          }.recover {
-            case _: Throwable =>
-              game.removeWaiter(playerId)
-              NoContent
-          }
-        }
-
-      case None =>
-        Future.successful(NotFound("Game not found."))
-    }
-  }
-
-
-}

knockoutwhistweb/app/controllers/WebsocketController.scala

@@ -0,0 +1,45 @@
+package controllers
+
+
+import auth.AuthAction
+import logic.PodManager
+import logic.user.SessionManager
+import model.sessions.{UserSession, UserWebsocketActor}
+import org.apache.pekko.actor.{ActorRef, ActorSystem, Props}
+import org.apache.pekko.stream.Materializer
+import play.api.*
+import play.api.libs.streams.ActorFlow
+import play.api.mvc.*
+
+import javax.inject.*
+
+
+@Singleton
+class WebsocketController @Inject()(
+                                     cc: ControllerComponents,
+                                     val sessionManger: SessionManager,
+                                   )(implicit system: ActorSystem, mat: Materializer) extends AbstractController(cc) {
+
+  def socket(): WebSocket = WebSocket.accept[String, String] { request =>
+    val session = request.cookies.get("sessionId")
+    if (session.isEmpty) throw new Exception("No session cookie found")
+    val userOpt = sessionManger.getUserBySession(session.get.value)
+    if (userOpt.isEmpty) throw new Exception("Invalid session")
+    val user = userOpt.get
+    val game = PodManager.identifyGameOfUser(user)
+    if (game.isEmpty) throw new Exception("User is not in a game")
+    val userSession = game.get.getUserSession(user.id)
+    ActorFlow.actorRef { out =>
+      println("Connect received")
+      KnockOutWebSocketActorFactory.create(out, userSession)
+    }
+  }
+
+  object KnockOutWebSocketActorFactory {
+    def create(out: ActorRef, userSession: UserSession): Props = {
+      Props(new UserWebsocketActor(out, userSession))
+    }
+  }
+
+
+}