5 files changed, 267 insertions, 0 deletions
diff --git a/src/main/scala/Model/Action.scala b/src/main/scala/Model/Action.scala
new file mode 100644
index 0000000..84704ce
--- /dev/null
+++ b/src/main/scala/Model/Action.scala
@@ -0,0 +1,31 @@
+package o1game.Model
+
+/** The class `Action` represents actions that a player may take in a text adventure game.
+  * `Action` objects are constructed on the basis of textual commands and are, in effect,
+  * parsers for such commands. An action object is immutable after creation.
+  * @param input	a textual in-game command such as “go east” or “rest” */
+class Action(input: String):
+
+	private val commandText = input.trim.toLowerCase
+	private val verb        = commandText.takeWhile( _ != ' ' )
+	private val modifiers   = commandText.drop(verb.length).trim
+
+	/** Causes the given player to take the action represented by this object, assuming
+	  * that the command was understood. Returns a description of what happened as a result
+	  * of the action (such as “You go west.”). The description is returned in an `Option`
+	  * wrapper; if the command was not recognized, `None` is returned. */
+	def execute(actor: Entity): Option[String] =
+		this.verb match
+			case "go"    => Some(actor.go(this.modifiers))
+			case "rest"  => Some(actor.rest())
+			case "get"   => Some(actor.pickUp(this.modifiers))
+			case "drop"  => Some(actor.drop(this.modifiers))
+			case "xyzzy" => Some("The grue tastes yummy.")
+			case "quit"  => Some(actor.quit())
+			case other   => None
+
+	/** Returns a textual description of the action object, for debugging purposes. */
+	override def toString = s"$verb (modifiers: $modifiers)"
+
+end Action
+
diff --git a/src/main/scala/Model/Adventure.scala b/src/main/scala/Model/Adventure.scala
new file mode 100644
index 0000000..c13ff47
--- /dev/null
+++ b/src/main/scala/Model/Adventure.scala
@@ -0,0 +1,56 @@
+package o1game.Model
+
+import scala.collection.mutable.Map
+/** The class `Adventure` represents text adventure games. An adventure consists of a player and
+  * a number of areas that make up the game world. It provides methods for playing the game one
+  * turn at a time and for checking the state of the game.
+  *
+  * N.B. This version of the class has a lot of “hard-coded” information that pertains to a very
+  * specific adventure game that involves a small trip through a twisted forest. All newly created
+  * instances of class `Adventure` are identical to each other. To create other kinds of adventure
+  * games, you will need to modify or replace the source code of this class. */
+class Adventure(val playerNames: Vector[String]):
+
+	/** the name of the game */
+	val title = "A Forest Adventure"
+
+	/*private*/ val middle = Area("Forest", "You are somewhere in the forest. There are a lot of trees here.\nBirds are singing.")
+	/*private*/ val northForest = Area("Forest", "You are somewhere in the forest. A tangle of bushes blocks further passage north.\nBirds are singing.")
+	/*private*/ val southForest = Area("Forest", "The forest just goes on and on.")
+	/*private*/ val clearing = Area("Forest Clearing", "You are at a small clearing in the middle of forest.\nNearly invisible, twisted paths lead in many directions.")
+	/*private*/ val tangle = Area("Tangle of Bushes", "You are in a dense tangle of bushes. It's hard to see exactly where you're going.")
+	/*private*/ val home = Area("Home", "Home sweet home! Now the only thing you need is a working remote control.")
+	/*private*/ val destination = home
+
+	middle.setNeighbors(Vector("north" -> northForest, "east" -> tangle, "south" -> southForest, "west" -> clearing))
+	northForest.setNeighbors(Vector("east" -> tangle, "south" -> middle, "west" -> clearing))
+	southForest.setNeighbors(Vector("north" -> middle, "east" -> tangle, "south" -> southForest, "west" -> clearing))
+	clearing.setNeighbors(Vector("north" -> northForest, "east" -> middle, "south" -> southForest, "west" -> northForest))
+	tangle.setNeighbors(Vector("north" -> northForest, "east" -> home,	 "south" -> southForest, "west" -> northForest))
+	home.setNeighbors(Vector("west" -> tangle))
+
+	clearing.addItem(Item("battery", "It's a small battery cell. Looks new."))
+	southForest.addItem(Item(
+		"remote",
+		"It's the remote control for your TV.\n" +
+		"What it was doing in the forest, you have no idea.\n" +
+		"Problem is, there's no battery."
+	))
+
+	val players: Map[String, Entity] = Map()
+	playerNames.foreach(name => players += name -> Entity(name, middle))
+	def getPlayer(name: String): Option[Entity] = this.players.get(name)
+
+	/** Returns a message that is to be displayed to the player at the beginning of the game. */
+	def welcomeMessage = "Generic welcome message"
+
+	/** Plays a turn by executing the given in-game command, such as “go west”. Returns a textual
+	  * report of what happened, or an error message if the command was unknown. In the latter
+	  * case, no turns elapse. */
+	def playTurnOfPlayer(playerName: String, command: String): Option[String] =
+		val action = Action(command)
+		val actor = this.players.get(playerName)
+		actor.flatMap(action.execute(_))
+
+end Adventure
+
diff --git a/src/main/scala/Model/Area.scala b/src/main/scala/Model/Area.scala
new file mode 100644
index 0000000..97c75bf
--- /dev/null
+++ b/src/main/scala/Model/Area.scala
@@ -0,0 +1,98 @@
+package o1game.Model
+
+import scala.collection.mutable.Map
+
+/** The class `Area` represents locations in a text adventure game world. A game world
+  * consists of areas. In general, an “area” can be pretty much anything: a room, a building,
+  * an acre of forest, or something completely different. What different areas have in
+  * common is that players can be located in them and that they can have exits leading to
+  * other, neighboring areas. An area also has a name and a description.
+  * @param name the name of the area
+  * @param description a basic description of the area (typically not including information about items) */
+class Area(val name: String, var description: String):
+
+	private val neighbors = Map[String, Area]()
+	private val items: Map[String, Item] = Map()
+	private val entities: Map[String, Entity] = Map()
+
+	/** Returns the area that can be reached from this area by moving in the given direction. The result
+	  * is returned in an `Option`; `None` is returned if there is no exit in the given direction. */
+	def neighbor(direction: String) = this.neighbors.get(direction)
+
+	/** Adds an exit from this area to the given area. The neighboring area is reached by moving in
+	  * the specified direction from this area. */
+	def setNeighbor(direction: String, neighbor: Area) =
+		this.neighbors += direction -> neighbor
+
+	/** Adds exits from this area to the given areas. Calling this method is equivalent to calling
+	  * the `setNeighbor` method on each of the given direction–area pairs.
+	  * @param exits contains pairs consisting of a direction and the neighboring area in that direction
+	  * @see [[setNeighbor]] */
+	def setNeighbors(exits: Vector[(String, Area)]) =
+		this.neighbors ++= exits
+
+	/** Adds the specified item
+	  *
+	  * @param item the item to add
+	  */
+	def addItem(item: Item): Unit = this.items += item.name -> item
+
+	/** Adds multiple items
+	  *
+	  * @param items a once iterable collection of items to add
+	  */
+	def addItems(items: IterableOnce[Item]) =
+		items.iterator.foreach(i => this.items += i.name -> i)
+
+	/** Removes the specified item if it exists.
+	  *
+	  * @param itemName the name of the item to remove
+	  * @return an option containing the removed item
+	  */
+	def removeItem(itemName: String): Option[Item] =
+		this.items.remove(itemName)
+
+	/** Adds the specified entity to the area.
+	  *
+	  * @param entity the entity to add.
+	  */
+	def addEntity(entity: Entity): Unit = this.entities += entity.name -> entity
+
+	/** Removes the entity with the name `entityName`.
+	  *
+	  * @param entityName the name of the entity to remove
+	  * @return an option containing the removed entity if it was in the area
+	  */
+	def removeEntity(entityName: String): Option[Entity] =
+		this.entities.remove(entityName)
+
+	/** Returns a multi-line description of the area as a player sees it. This includes a basic
+		* description of the area as well as information about exits and items. If there are no
+		* items present, the return value has the form "DESCRIPTION\n\nExits available:
+		* DIRECTIONS SEPARATED BY SPACES". If there are one or more items present, the return
+		* value has the form "DESCRIPTION\nYou see here: ITEMS SEPARATED BY SPACES\n\nExits available:
+		* DIRECTIONS SEPARATED BY SPACES". The items and directions are listed in an arbitrary order. */
+	def fullDescription: String =
+		val exitList = this.neighbors.keys.mkString(" ")
+		val itemList = this.items.keys.mkString(" ")
+		val entityList = this.entities.keys.mkString(" ")
+		val itemDescription =
+			if this.items.nonEmpty then
+				s"\nYou see here: ${itemList}"
+			else ""
+		val entityDescription =
+			if this.entities.nonEmpty then
+				s"\nThere are entities: ${entityList}"
+			else ""
+		(this.description +
+			itemDescription +
+			entityDescription +
+			s"\n\nExits available: $exitList")
+
+
+	/** Returns a single-line description of the area for debugging purposes. */
+	override def toString =
+		this.name + ": " + this.description.replaceAll("\n", " ").take(150)
+
+end Area
+
diff --git a/src/main/scala/Model/Entity.scala b/src/main/scala/Model/Entity.scala
new file mode 100644
index 0000000..eb19606
--- /dev/null
+++ b/src/main/scala/Model/Entity.scala
@@ -0,0 +1,64 @@
+package o1game.Model
+
+import scala.collection.mutable.Map
+
+/** A `Player` object represents a player character controlled by the real-life user
+  * of the program.
+  *
+  * A player object’s state is mutable: the player’s location and possessions can change,
+  * for instance.
+  *
+  * @param startingArea the player’s initial location */
+class Entity(val name: String, initialLocation: Area):
+	private var currentLocation: Area = initialLocation
+	private var quitCommandGiven = false // one-way flag
+	private val inventory: Map[String, Item] = Map()
+
+	/** Determines if the player has indicated a desire to quit the game. */
+	def hasQuit = this.quitCommandGiven // TODO: This is probably unneccessary?
+
+	/** Returns the player’s current location. */
+	def location = this.currentLocation
+
+	/** Attempts to move the player in the given direction. This is successful if there
+	  * is an exit from the player’s current location towards the direction name. Returns
+	  * a description of the result: "You go DIRECTION." or "You can't go DIRECTION." */
+	def go(direction: String) =
+		val destination = this.location.neighbor(direction)
+		if destination.isDefined then
+			this.currentLocation.removeEntity(this.name)
+			this.currentLocation = destination.getOrElse(this.currentLocation)
+			destination.foreach(_.addEntity(this))
+			s"You go $direction."
+		else
+			"You can't go " + direction + "."
+
+	def pickUp(itemName: String): String =
+		this.currentLocation.removeItem(itemName) match
+			case Some(i) =>
+				this.inventory += i.name -> i
+				s"You pick up the ${i.name}"
+			case None => s"There is no $itemName here to pick up."
+
+	def drop(itemName: String): String =
+		this.inventory.remove(itemName) match
+			case Some(item) =>
+				this.currentLocation.addItem(item)
+				s"You drop the $itemName"
+			case None => "You don't have that!"
+
+	/** Causes the player to rest for a short while (this has no substantial effect in game terms).
+	  * Returns a description of what happened. */
+	def rest() =
+		"You rest for a while. Better get a move on, though."
+
+	/** Signals that the player wants to quit the game. Returns a description of what happened within
+	  * the game as a result (which is the empty string, in this case). */
+	def quit() =
+		this.quitCommandGiven = true
+		""
+
+	/** Returns a brief description of the player’s state, for debugging purposes. */
+	override def toString = "Now at: " + this.location.name
+
+end Entity
diff --git a/src/main/scala/Model/Item.scala b/src/main/scala/Model/Item.scala
new file mode 100644
index 0000000..3809561
--- /dev/null
+++ b/src/main/scala/Model/Item.scala
@@ -0,0 +1,18 @@
+package o1game.Model
+
+/** The class `Item` represents items in a text adventure game. Each item has a name
+  * and a longer description. (In later versions of the adventure game, items may
+  * have other features as well.)
+  *
+  * N.B. It is assumed, but not enforced by this class, that items have unique names.
+  * That is, no two items in a game world have the same name.
+  *
+  * @param name the item’s name
+  * @param description the item’s description */
+class Item(val name: String, val description: String):
+
+	/** Returns a short textual representation of the item (its name, that is). */
+	override def toString = this.name
+
+end Item
+