Made the server work with the adventure model

* The model was imported from the wrong version, so that needs to be fixed.
* The client side doesn't work at all right now. Use netcat for testing.
* There are inconveniences and bugs in the model (eg. it lists the player among entities)
* Players can just see each other, not interact in any way
But it's a good base.

5 files changed, 183 insertions, 63 deletions

diff --git a/src/main/scala/Server/Character.scala b/src/main/scala/Server/Character.scala
index 082f152..174b7b0 100644
--- a/src/main/scala/Server/Character.scala
+++ b/src/main/scala/Server/Character.scala
@@ -2,6 +2,6 @@ package o1game.Server
 
 import scala.collection.mutable.Buffer
 
-class GameCharacter(val name: String, initialItems: Iterable[String]):
-	private val items: Buffer[String] = Buffer.from(items) // TODO: Item class
+class GameCharacter(val name: String):
+	private val items: Buffer[String] = Buffer.empty // TODO: Item class
 	// TODO: A lot of other things too
diff --git a/src/main/scala/Server/Client.scala b/src/main/scala/Server/Client.scala
index 3bc4012..1e5dd00 100644
--- a/src/main/scala/Server/Client.scala
+++ b/src/main/scala/Server/Client.scala
@@ -1,23 +1,36 @@
 package o1game.Server
 
 import java.net.Socket
-import scala.util.Try
 import scala.math.min
 import o1game.constants.*
+import ServerProtocolState.*
+import o1game.Model.Entity
+import o1game.Model.Action
 
-object Client:
-	def parseClient(data: String, socket: Socket): Client =
-		Client(socket, Some(GameCharacter(data, Vector())))
-
-class Client(val socket: Socket, val character: Option[GameCharacter]):
+class Client(val socket: Socket):
 	private var incompleteMessage: Array[Byte] =
 		Array.fill(MAX_MSG_SIZE)(0.toByte)
 	private var incompleteMessageIndex = 0
+	private var protocolState = WaitingForVersion
+	private var outData: String = ""
+	private var character: Option[Entity] = None
+	private var protocolIsIntact = true
+	private var name: Option[String] = None
 
 	/** Calculates the amount of bytes available for future incoming messages
 	 */
 	def spaceAvailable: Int = MAX_MSG_SIZE - incompleteMessageIndex
 
+	def isIntactProtocolWise: Boolean = protocolIsIntact
+	def isReadyForGameStart: Boolean =
+		this.protocolState == WaitingForGameStart
+	def gameStart(): Unit = this.protocolState = InGame
+	def entity: Option[Entity] = this.character
+	def giveEntity(entity: Entity): Unit =
+		println(entity)
+		this.character = Some(entity)
+	def getName: Option[String] = this.name
+
 	/** Sets `data` as received for the client.
 	 *
 	 *  @return false means there was not enough space to receive the message
@@ -30,6 +43,23 @@ class Client(val socket: Socket, val character: Option[GameCharacter]):
 			min(this.incompleteMessageIndex, MAX_MSG_SIZE)
 		data.length < spaceAvailable
 
+	/** Returns data that should be sent to this client.
+	 *  The data is cleared when calling.
+	 */
+	def dataToThisClient(): String =
+		val a = this.outData
+		this.outData = ""
+		a
+
+	/** Specifies that the data should be buffered for
+	 *  sending to this client
+	 *
+	 * @param data data to buffer for sending
+	 */
+	private def addDataToSend(data: String): Unit =
+		this.outData += s"$data\n"
+
+
 	/** Returns one line of data if there are any line breaks.
 	 *  Removes the parsed data from the message buffering area.
 	 */
@@ -46,60 +76,42 @@ class Client(val socket: Socket, val character: Option[GameCharacter]):
 
 	/** Causes the client to take the actions it has received
 	 */
-	def executeActions(): Unit =
+	def interpretData(): Unit =
 		LazyList.continually(this.nextLine())
 			.takeWhile(_.isDefined)
 			.flatten
-			.foreach(s => println(s"`$this` executing `$s`"))
-
-
-class Clients(maxClients: Int):
-	private val clients: Array[Option[Client]] = Array.fill(maxClients)(None)
+			.foreach(s => takeAction(s))
 
-	/** Adds `client` to this collection of clients.
+	/** Makes the client execute the action specified by `line`.
+	 *  If there is a protocol error, the function changes
+	 *  the variable `protocolIsIntact` to false.
 	 *
-	 * @param client the Client to add
-	 * @return true if there was room for the client
-	 *         i.e. fewer clients than `maxClients`, false otherwise
+	 * @param line the line to interpret
 	 */
-	def addClient(client: Client): Boolean =
-		val i = this.clients.indexOf(None)
-		if i == -1 then
-			false
-		else
-			this.clients(i) = Some(client)
-			true
+	private def takeAction(line: String): Unit =
+		this.protocolIsIntact = this.protocolState match
+			case WaitingForVersion =>
+				if line == GAME_VERSION then
+					addDataToSend(PROTOCOL_VERSION_GOOD)
+					this.protocolState = WaitingForClientName
+					true
+				else
+					addDataToSend(PROTOCOL_VERSION_BAD)
+					false
+			case WaitingForClientName =>
+				this.name = Some(line)
+				this.protocolState = WaitingForGameStart
+				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) match
+					case Some(s) => this.addDataToSend(s)
+				true
 
-	/** Returns all the clients.
-	 *
-	 * @return an iterable of all the clients
-	 */
-	def allClients: Iterable[Client] = clients.toVector.flatten
+end Client
 
-	/** Applies the function `f` to all the clients for its side effects. */
-	def foreach(f: Client => Any): Unit = this.clients.flatten.foreach(f)
-
-	/** Applies the function `f` to all the clients for its side effects
-	 *  and removes all the clients for which `f([client])` returns false.
-	 *  This is useful for doing IO with the client and removing clients
-	 *  with stale sockets.
-	 *
-	 * @param f the function to apply to all the clients and filter them with
-	 */
-	def removeNonSatisfying(f: Client => Boolean): Unit =
-		for i <- this.clients.indices do
-			this.clients(i) match
-				case Some(c) =>
-					if !f(c) then
-						this.clients(i) = None
-				case None =>
-
-	/** Applies the function f to all clients for its side effects.
-	 *  If the function throws an exception, the client is removed.
-	 *  Probably a more concise alternative to `removeNonSatisfying`,
-	 *  but might catch exceptions unintentionally.
-	 *
-	 * @param f the function to apply for its side effects to each client
-	 */
-	def mapAndRemove(f: Client => Unit): Unit =
-		this.removeNonSatisfying(c => Try(f(c)).isSuccess)
\ No newline at end of file
diff --git a/src/main/scala/Server/Clients.scala b/src/main/scala/Server/Clients.scala
new file mode 100644
index 0000000..24a245c
--- /dev/null
+++ b/src/main/scala/Server/Clients.scala
@@ -0,0 +1,70 @@
+package o1game.Server
+
+import scala.util.Try
+
+class Clients(maxClients: Int):
+	private val clients: Array[Option[Client]] = Array.fill(maxClients)(None)
+
+	/** Adds `client` to this collection of clients.
+	 *
+	 * @param client the Client to add
+	 * @return true if there was room for the client
+	 *         i.e. fewer clients than `maxClients`, false otherwise
+	 */
+	def addClient(client: Client): Boolean =
+		val i = this.clients.indexOf(None)
+		if i == -1 then
+			false
+		else
+			this.clients(i) = Some(client)
+			true
+
+	/** Returns all the clients.
+	 *
+	 * @return an iterable of all the clients
+	 */
+	def allClients: Iterable[Client] = clients.toVector.flatten
+
+	/** Applies the function `f` to all the clients for its side effects. */
+	def foreach(f: Client => Any): Unit = this.clients.flatten.foreach(f)
+
+	/** Returns true if the predicate `f` stands for all clients,
+	  * false otherwise
+	  *
+	  * @param f the predicate to check for all clients
+	  * @return whether `f` stands for all clients
+	  */
+	def forall(f: Client => Boolean): Boolean = this.clients.flatten.forall(f)
+
+	def names: Vector[String] = this.clients.flatten.flatMap(_.getName).toVector
+
+	def isEmpty: Boolean = this.clients.flatten.isEmpty
+
+	/** Applies the function `f` to all the clients for its side effects
+	 *  and removes all the clients for which `f([client])` returns false.
+	 *  This is useful for doing IO with the client and removing clients
+	 *  with stale sockets.
+	 *
+	 * @param f the function to apply to all the clients and filter them with
+	 */
+	def removeNonSatisfying(f: Client => Boolean): Unit =
+		for i <- this.clients.indices do
+			this.clients(i) match
+				case Some(c) =>
+					if !f(c) then
+						this.clients(i) = None
+				case None =>
+
+	/** Removes clients that have not behaved according to protocol */
+	def removeNonCompliant(): Unit =
+		this.removeNonSatisfying(_.isIntactProtocolWise)
+
+	/** Applies the function f to all clients for its side effects.
+	 *  If the function throws an exception, the client is removed.
+	 *  Probably a more concise alternative to `removeNonSatisfying`,
+	 *  but might catch exceptions unintentionally.
+	 *
+	 * @param f the function to apply for its side effects to each client
+	 */
+	def mapAndRemove(f: Client => Unit): Unit =
+		this.removeNonSatisfying(c => Try(f(c)).isSuccess)
diff --git a/src/main/scala/Server/Server.scala b/src/main/scala/Server/Server.scala
index 1f0cbfc..c0a76ca 100644
--- a/src/main/scala/Server/Server.scala
+++ b/src/main/scala/Server/Server.scala
@@ -7,34 +7,56 @@ import java.io.IOException
 import java.lang.Thread.sleep
 import java.net.{ServerSocket, Socket}
 import o1game.constants.*
+import o1game.Model.Adventure
+import o1game.Model.Entity
+import scala.collection.mutable.Map
+
+def stringToByteArray(str: String): Array[Byte] =
+	str.toVector.map(_.toByte).toArray
 
 /** `Server` exists to initialize a server for the game
  *  and run it with its method `startServer`.
  */
-class Server(port: Int, maxClients: Int):
+class Server(port: Int, maxClients: Int, val timeLimit: Int):
 	private val socket = ServerSocket(port)
 	private val clientGetter = ConnectionGetter(socket)
 	private val clients: Clients = Clients(maxClients)
 	private val buffer: Array[Byte] = Array.ofDim(1024)
 	private var bufferIndex = 0
+	private var adventure: Option[Adventure] = None
 
 	/** Starts the server. Won't terminate under normal circumstances. */
 	def startServer(): Unit =
 		while true do
 			sleep(POLL_INTERVAL)
 			this.receiveNewClient()
-			this.writeToAll("Test message.")
 			this.readFromAll()
-			clients.foreach(_.executeActions())
+			this.writeClientDataToClients()
+			this.clients.removeNonCompliant()
+			this.clients.foreach(_.interpretData())
+			if this.adventure.isEmpty && !this.clients.isEmpty && this.clients.forall(_.isReadyForGameStart) then
+				this.adventure = Some(Adventure(this.clients.names))
+				this.clients.foreach( c =>
+					c.gameStart()
+					val name = c.getName
+					val entity: Option[Entity] = name match
+						case Some(n) => this.adventure match
+							case Some(a) => a.getPlayer(n)
+							case None => None
+						case None => None
+					entity.map(c.giveEntity(_))
+				)
+				this.writeToAll(s"$timeLimit")
+
 
 	/** Receives a new client and stores it in `clients`.
 	 *
 	 *  @return describes if a client was added
 	 */
 	private def receiveNewClient(): Boolean =
-		clientGetter.newClient() match
+		this.clientGetter.newClient() match
 			case Some(c) =>
-				clients.addClient(Client(c, None))
+				clients.addClient(Client(c))
 				true
 			case None =>
 				false
@@ -44,12 +66,21 @@ class Server(port: Int, maxClients: Int):
 	 *  @param message the message to send
 	 */
 	private def writeToAll(message: String): Unit =
-		clients.mapAndRemove(c =>
+		this.clients.mapAndRemove(c =>
 			val output = c.socket.getOutputStream
 			output.write(message.toVector.map(_.toByte).toArray)
 			output.flush()
 		)
 
+	/** Sends every client's `dataToThisClient` to the client */
+	private def writeClientDataToClients(): Unit =
+		this.clients.mapAndRemove(c =>
+			val output = c.socket.getOutputStream
+			val data = c.dataToThisClient()
+			output.write(data.toVector.map(_.toByte).toArray)
+			output.flush()
+		)
+
 	/** Reads data sent by clients and stores it in the `Client`s of `clients` */
 	private def readFromAll(): Unit =
 		clients.mapAndRemove(c =>
diff --git a/src/main/scala/Server/constants.scala b/src/main/scala/Server/constants.scala
index 4260a60..ddaab00 100644
--- a/src/main/scala/Server/constants.scala
+++ b/src/main/scala/Server/constants.scala
@@ -4,3 +4,10 @@ package o1game.constants
 val MAX_MSG_SIZE = 1024 // bytes
 val LF: Byte = 10
 val POLL_INTERVAL = 100 // millisec.
+val GAME_VERSION = "0.1.0"
+
+val PROTOCOL_VERSION_GOOD = "version ok"
+val PROTOCOL_VERSION_BAD = "version bad"
+
+enum ServerProtocolState:
+	case WaitingForVersion, WaitingForClientName, WaitingForGameStart, InGame