From 129b49a3876ceb68f271c311d5e45efb2e205300 Mon Sep 17 00:00:00 2001 From: Joel Kronqvist Date: Sat, 9 Nov 2024 16:32:09 +0200 Subject: Made & implemented clearer protocol, added client functionality --- src/main/scala/Client/Client.scala | 210 +++++++++++++++++++++++++++++++++++-- 1 file changed, 200 insertions(+), 10 deletions(-) (limited to 'src/main/scala/Client/Client.scala') diff --git a/src/main/scala/Client/Client.scala b/src/main/scala/Client/Client.scala index 1b843ab..ef98ef3 100644 --- a/src/main/scala/Client/Client.scala +++ b/src/main/scala/Client/Client.scala @@ -3,26 +3,216 @@ package o1game.Client import java.lang.Thread.sleep import java.net.Socket import scala.io.Source +import scala.io.StdIn.readLine import scala.sys.process.stdout +import java.io.InputStream import o1game.constants.* +import o1game.utils.stringToByteArray +import scala.concurrent.Future +import scala.concurrent.ExecutionContext.Implicits.global +import scala.util.{Try, Success, Failure} +import scala.collection.mutable.Buffer +import scala.collection.immutable.LazyList +import java.lang.System.currentTimeMillis -class Client(ip: String, port: Int): - private val socket = Socket(ip, port) +def newClient(name: String, ip: String, port: Int): Option[Client] = + val socket = Socket(ip, port) + val output = socket.getOutputStream + val input = socket.getInputStream + val initMsg = s"$GAME_VERSION\r\n$name\r\n" + output.write(stringToByteArray(initMsg)) + val msgLen = (PROTOCOL_VERSION_GOOD + "\r\n").length + val versionResponse = getNCharsFromSocket(input, msgLen) + if versionResponse == Some(s"$PROTOCOL_VERSION_GOOD\r\n") then + Some(Client(socket)) + else + None + +def getNCharsFromSocket(input: InputStream, n: Int): Option[String] = + val buffer: Array[Byte] = Array.ofDim(n) + var i = 0 + var failed = false + while i < n && !failed do + val res = input.read(buffer, i, n - i) + if res < 0 then failed = true + i += res + // TODO: better error handling + if failed then None else Some(String(buffer)) + +/** This class is for taking new lines from stdin when they are available. + * reading starts when either newLine or clear or startReading are called. + */ +class StdinLineReader: + + private var nextLine: Future[String] = Future.failed(Exception()) + + /** Returns a new line of input if there are any. */ + def newLine(): Option[String] = + this.nextLine.value match + case Some(Success(s)) => + this.nextLine = Future(readLine()) + Some(s) + case Some(Failure(e)) => + this.nextLine = Future(readLine()) + None + case None => None + + /** Discards the line that is currently being read and restarts reading */ + def clear(): Unit = + this.nextLine = Future(readLine()) + + /** Equivalent to clear */ + def startReading(): Unit = this.clear() + +end StdinLineReader + +enum ServerLineState: + case WaitingForGameStart, + ActionDescription, + TurnIndicator, + AreaDescription, + Directions, + Items, + Entities + + +//def indexOfCRLF(data: IndexedSeq[Byte]): Int = +// val LF = data.indexOf(10) +// data.get(LF + 1).filter(_ == 13).filter(a => LF == -1).getOrElse(-1) +// +//def splitAtCRLF(data: IndexedSeq[Byte]): Vector[] + +class ServerDataParser: + + private var serverLineState = ServerLineState.ActionDescription + + private var bufferedData: Buffer[Byte] = Buffer.empty // TODO: suboptimal DS + + def in(data: Array[Byte]): Unit = + this.bufferedData ++= data + + def nextLine(): Option[String] = + val indexOfCRLF = this.bufferedData.indexOfSlice(CRLF) + if indexOfCRLF == -1 then + None + else + val splitData = this.bufferedData.splitAt(indexOfCRLF) + this.bufferedData = Buffer.from(splitData(1).drop(CRLF.length)) + Some(String(splitData(0).toArray)) + +end ServerDataParser + +class Client(socket: Socket): private val input = socket.getInputStream private val output = socket.getOutputStream private val buffer: Array[Byte] = Array.ofDim(MAX_MSG_SIZE) private var bufferIndex = 0 + private var serverLineState = ServerLineState.WaitingForGameStart + private val serverLineParser = ServerDataParser() + private val stdinReader = StdinLineReader() + private var timeLimit: Long = 0 + + private var lastTurnStart: Long = 0 + private var lastExecutedTurn: Long = 0 + assert( + lastTurnStart <= lastExecutedTurn, + "don't initialize with unexecuted turn" + ) + + // TODO: extract these to a separate area object for the client + private var actions: Buffer[String] = Buffer.empty + private var areaDescription: String = "" + private var possibleDirections: Array[String] = Array.empty + private var visibleItems: Array[String] = Array.empty + private var visibleEntities: Array[String] = Array.empty + + + private def readAndParseDataFromServer(): Unit = + var availableBytes = input.available() + while availableBytes != 0 do + val bytesRead = input.read(buffer, 0, availableBytes) + if bytesRead != -1 then + // TODO: unsafe conversion + parseDataFromServer(buffer.take(bytesRead)) + availableBytes = input.available() + + private def giveTurn(): String = + this.lastExecutedTurn = currentTimeMillis / 1000 + val actionDesc = this.actions.mkString("\n") + this.actions = Buffer.empty + val itemDesc = "You can see the following items: " + + this.visibleItems.mkString(", ") + val entityDesc = "The following entities reside in the room: " + + this.visibleEntities.mkString(", ") + val directionDesc = "There are exits to " + + this.possibleDirections.mkString(", ") + (s"\n$actionDesc\n\n$areaDescription\n$directionDesc\n" + + s"\n$itemDesc\n$entityDesc") + def startClient(): Unit = + stdinReader.startReading() + + // TODO: read data from server and store it in the turn description + // TODO: if turn isn't executed since lastturnstart, display the data + // and clean STDIN + // TODO: write data from stdin and send it to the server + // TODO: display timer to next turn end while true do sleep(POLL_INTERVAL) - while input.available() != 0 do - val bytesRead = input.read(buffer) - if bytesRead != -1 then - print(buffer.take(bytesRead).toVector.map(_.toChar).mkString) - stdout.flush() + this.readAndParseDataFromServer() + + if this.lastExecutedTurn < this.lastTurnStart then + println(this.giveTurn()) + + stdinReader.newLine().foreach((s: String) => + output.write(stringToByteArray(s+"\r\n")) + ) + + if this.timeLimit != 0 && this.lastTurnStart != 0 then + val timeOfTurnEnd = this.lastTurnStart + this.timeLimit + val timeToTurnEnd = -currentTimeMillis()/1000 + timeOfTurnEnd + print(s"\r[$timeToTurnEnd]> ") + + private def parseDataFromServer(data: Array[Byte]): Unit = + this.serverLineParser.in(data) + var nextLine: Option[String] = Some("") + while nextLine.isDefined do + nextLine = this.serverLineParser + .nextLine() + nextLine + .foreach(this.parseLineFromServer(_)) + + private def parseLineFromServer(line: String) = + if line == TURN_INDICATOR then + this.serverLineState = ServerLineState.TurnIndicator + serverLineState match + case ServerLineState.WaitingForGameStart => + val time = line.toLongOption + time match + case Some(t) => this.timeLimit = t + case None => print("Invalid time limit, oh no!!!") + this.serverLineState = ServerLineState.ActionDescription + case ServerLineState.ActionDescription => + this.actions.append(line) + case ServerLineState.TurnIndicator => + this.serverLineState = ServerLineState.AreaDescription + case ServerLineState.AreaDescription => + this.areaDescription = line + this.serverLineState = ServerLineState.Directions + case ServerLineState.Directions => + this.possibleDirections = line.split(LIST_SEPARATOR) + this.serverLineState = ServerLineState.Items // TODO: maybe use a list instead? + case ServerLineState.Items => + this.visibleItems = line.split(LIST_SEPARATOR) + this.serverLineState = ServerLineState.Entities + case ServerLineState.Entities => + this.visibleEntities = line.split(LIST_SEPARATOR) + this.serverLineState = ServerLineState.ActionDescription + this.lastTurnStart = currentTimeMillis() / 1000 + - bufferIndex = s"Houston, I think this shouldn't be so hard.\n".toVector.map(_.toByte).copyToArray(buffer) - output.write(buffer, 0, bufferIndex) - output.flush() \ No newline at end of file + //bufferIndex = s"Houston, I think this shouldn't be so hard.\n".toVector.map(_.toByte).copyToArray(buffer) + //output.write(buffer, 0, bufferIndex) + //output.flush() -- cgit v1.2.3