Added turns, time limits and turn order randomization (feature/bug?)

3 files changed, 66 insertions, 14 deletions

diff --git a/src/main/scala/Server/Client.scala b/src/main/scala/Server/Client.scala
index d9fa684..e557c22 100644
--- a/src/main/scala/Server/Client.scala
+++ b/src/main/scala/Server/Client.scala
@@ -16,6 +16,7 @@ class Client(val socket: Socket):
 	private var character: Option[Entity] = None
 	private var protocolIsIntact = true
 	private var name: Option[String] = None
+	private var nextAction: Option[Action] = None
 
 	/** Calculates the amount of bytes available for future incoming messages */
 	def spaceAvailable: Int = MAX_MSG_SIZE - incompleteMessageIndex
@@ -106,12 +107,22 @@ class Client(val socket: Socket):
 		else
 			None
 
-	/** Causes the client to take the actions it has received */
+	/** Makes the client play its turn */
+	def act(): Unit =
+		this.nextAction.foreach(this.executeAction(_))
+		this.nextAction = None
+
+	/** Checks whether the client has chosen its next action
+	  *
+	  * @return whether the client is ready to act */
+	def isReadyToAct: Boolean = this.nextAction.isDefined
+
+	/** Causes the client to interpret the data it has received */
 	def interpretData(): Unit =
 		LazyList.continually(this.nextLine())
 			.takeWhile(_.isDefined)
 			.flatten
-			.foreach(s => takeAction(s))
+			.foreach(s => interpretLine(s))
 
 	/** Makes the client execute the action specified by `line`.
 	  *  If there is a protocol error, the function changes
@@ -119,7 +130,7 @@ class Client(val socket: Socket):
 	  *
 	  * @param line the line to interpret
 	  */
-	private def takeAction(line: String): Unit =
+	private def interpretLine(line: String): Unit =
 		this.protocolIsIntact = this.protocolState match
 			case WaitingForVersion =>
 				if line == GAME_VERSION then
@@ -135,15 +146,29 @@ class Client(val socket: Socket):
 				true
 			case WaitingForGameStart => true
 			case InGame =>
-				println(line)
-				val action = Action(line)
-				this.character.flatMap(action.execute(_)) match
-					case Some(s) => this.addDataToSend(s)
-					case None => this.addDataToSend("You can't do that")
-				this.character
-					.map(_.location.fullDescription)
-					.foreach(this.addDataToSend(_))
+				this.bufferAction(Action(line))
 				true
 
+	/** Buffers the action for execution or executes it immediately if it
+	  * doesn't take a turn */
+	private def bufferAction(action: Action) =
+		if (
+			this.nextAction.isEmpty &&
+			this.entity.exists(action.takesATurnFor(_))
+		) then
+			this.nextAction = Some(action)
+			this.addDataToSend("Waiting for everyone to end their turns...")
+		else if this.nextAction.isEmpty then
+			executeAction(action)
+
+	/** Executes the specified action */
+	private def executeAction(action: Action) =
+		this.character.flatMap(action.execute(_)) match
+			case Some(s) => this.addDataToSend((s))
+			case None => this.addDataToSend("You can't do that")
+		this.character.map(_.location.fullDescription)
+			.foreach(this.addDataToSend(_))
+
+
 end Client
 
diff --git a/src/main/scala/Server/Clients.scala b/src/main/scala/Server/Clients.scala
index 786a09a..6487446 100644
--- a/src/main/scala/Server/Clients.scala
+++ b/src/main/scala/Server/Clients.scala
@@ -1,6 +1,7 @@
 package o1game.Server
 
 import scala.util.Try
+import scala.util.Random
 
 class Clients(maxClients: Int):
 	private val clients: Array[Option[Client]] = Array.fill(maxClients)(None)
@@ -28,6 +29,13 @@ class Clients(maxClients: Int):
 	/** Applies the function `f` to all the clients for its side effects. */
 	def foreach(f: Client => Any): Unit = this.clients.flatten.foreach(f)
 
+	/** Executes the function `f` for all clients in a pseudorandom order. */
+	def inRandomOrder(f: Client => Any): Unit =
+		Random.shuffle(this
+			.clients
+			.flatten)
+			.foreach(f)
+
 	/** Returns true if the predicate `f` stands for all clients,
 	  * false otherwise
 	  *
diff --git a/src/main/scala/Server/Server.scala b/src/main/scala/Server/Server.scala
index 2f78e6b..faf82e1 100644
--- a/src/main/scala/Server/Server.scala
+++ b/src/main/scala/Server/Server.scala
@@ -3,13 +3,13 @@ package o1game.Server
 
 // TODO: TLS/SSL / import javax.net.ssl.SSLServerSocketFactory
 
-import java.lang.Thread.sleep
+import java.lang.Thread.{currentThread, sleep}
 import java.net.{ServerSocket, Socket}
 import o1game.constants.*
 import o1game.Model.Adventure
 import o1game.Model.Entity
-import scala.util.Try
 
+import java.lang.System.currentTimeMillis
 import scala.util.Try
 
 /** Converts this string to an array of bytes (probably for transmission).
@@ -43,6 +43,7 @@ class Server(
 	private val buffer: Array[Byte] = Array.ofDim(1024)
 	private var bufferIndex = 0
 	private var adventure: Option[Adventure] = None
+	private var previousTurn = 0.0
 
 	/** Starts the server. Won't terminate under normal circumstances. */
 	def startServer(): Unit =
@@ -57,6 +58,11 @@ class Server(
 		this.writeClientDataToClients()
 		this.clients.removeNonCompliant()
 		this.clients.foreach(_.interpretData())
+		if this.canExecuteTurns then
+				println("taking turns")
+				this.clients.inRandomOrder(_.act())
+				this.writeToAll("next turn!")
+				this.previousTurn = currentTimeMillis() / 1000
 		if this.adventure.isDefined && this.joinAfterStart then
 			this.clients.foreach( c => if c.isReadyForGameStart then
 				this.adventure.foreach(a =>
@@ -67,6 +73,7 @@ class Server(
 		else if this.adventure.isEmpty && !this.clients.isEmpty && this.clients.forall(_.isReadyForGameStart) then
 			this.adventure = Some(Adventure(this.clients.names))
 			this.clients.foreach(startGameForClient(_))
+			this.previousTurn = currentTimeMillis() / 1000
 
 	/** Helper function to start the game for the specified client c.
 	  * MAY ONLY BE USED IF `this.adventure` is Some!
@@ -83,10 +90,22 @@ class Server(
 				case Some(a) => a.getPlayer(n)
 				case None => None
 			case None => None
-		entity.map(c.giveEntity(_))
+		entity.foreach(c.giveEntity(_))
 		this.writeToClient(s"$timeLimit", c)
 
 
+	/** Helper function to determine if the next turn can be taken */
+	private def canExecuteTurns: Boolean =
+		val requirement1 = this.adventure.isDefined
+		val requirement2 = !this.clients.isEmpty // nice! you can just return
+		                                         // to the game after everyone
+		                                         // left and everything is just
+		                                         // as before!
+		val allPlayersReady = this.clients.forall(_.isReadyToAct)
+		val requirement3 = (allPlayersReady
+			|| currentTimeMillis() / 1000 >= previousTurn + timeLimit)
+		requirement1 && requirement2 && requirement3
+
 
 	/** Receives a new client and stores it in `clients`.
 	  *