1 files changed, 117 insertions, 0 deletions
diff --git a/src/scalevalapokalypsi/Model/Area.scala b/src/scalevalapokalypsi/Model/Area.scala
new file mode 100644
index 0000000..c891af8
--- /dev/null
+++ b/src/scalevalapokalypsi/Model/Area.scala
@@ -0,0 +1,117 @@
+package scalevalapokalypsi.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): Option[Area] =
+		this.neighbors.get(direction)
+
+	def getNeighborNames: Iterable[String] = this.neighbors.keys
+	def getItemNames: Iterable[String] = this.items.keys
+	def getEntityNames: Iterable[String] = this.entities.values.map(_.name)
+	def getEntity(name: String): Option[Entity] = this.entities.get(name)
+	def getEntities: Iterable[Entity] = this.entities.values
+
+	/** Tells whether this area has a neighbor in the given direction.
+	 *
+	 * @param direction the direction to check
+	 * @return whether there is a neighbor in the direction
+	 */
+	def hasNeighbor(direction: String): Boolean =
+		this.neighbors.contains(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)
+
+	def hasItem(itemName: String) = this.items.contains(itemName)
+
+
+	/** 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.toLowerCase -> 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.toLowerCase())
+
+	/** 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.getEntityNames.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
+