Update

.vscode/settings.json

@@ -47,7 +47,8 @@
         "stdexcept": "cpp",
         "streambuf": "cpp",
         "typeinfo": "cpp",
-        "cassert": "cpp"
+        "cassert": "cpp",
+        "map": "cpp"
     },
     "C_Cpp.errorSquiggles": "Enabled"
 }

AttackEnemyOption.cpp

@@ -1,13 +1,26 @@
 #include "AttackEnemyOption.h"
 #include "Enemy.h"
 #include "Player.h"
+#include <array>
+#include <cassert>
 #include <iostream>
 
-AttackEnemyOption::AttackEnemyOption(Enemy* enemy, const std::string& outputText)
-	: m_enemy{enemy} , Option(PlayerOptions::AttackEnemy, outputText) { }
+namespace {
+	std::array<const char*, static_cast<size_t>(EnemyType::Max)> ENEMY_NAMES {
+		"dragon",
+		"orc"
+	};
+}
+
+
+AttackEnemyOption::AttackEnemyOption()
+	: Option(PlayerOptions::AttackEnemy, "Attack Enemy") { }
 
 void AttackEnemyOption::Evaluate(Player& player) {
-	std::cout << std::endl << "You have chosen to " << m_outputText << std::endl << std::endl;
+	assert(m_enemy);
+
+	const char* enemyName = ENEMY_NAMES[static_cast<unsigned int>(m_enemy->GetType())];
+	std::cout << std::endl << "You have chosen to attack the " << enemyName << std::endl << std::endl;
 
 	if (player.HasWeapon())	{
 		if (m_enemy->IsAlive())	{

AttackEnemyOption.h

@@ -1,15 +1,18 @@
 #pragma once
 
 #include "Option.h"
-
-class Enemy;
+#include "Enemy.h"
 
 class AttackEnemyOption	: public Option {
 private:
-	Enemy* m_enemy;
+	Enemy::Pointer m_enemy;
 
 public:
-	AttackEnemyOption(Enemy* enemy, const std::string& outputText);
+	AttackEnemyOption();
+
+	void SetEnemy(Enemy::Pointer enemy) {
+		m_enemy = enemy;
+	}
 
 	virtual void Evaluate(Player& player);
 };

Enemy.h

@@ -1,13 +1,12 @@
 #pragma once
 
 #include "Entity.h"
+#include "EnemyFactory.h"
+#include <memory>
 
 class Enemy	: public Entity {
 public:
-	enum class EnemyType {
-		Dragon,
-		Orc
-	};
+	using Pointer = std::shared_ptr<Enemy>;
 
 private:
 	EnemyType m_type;
@@ -16,6 +15,10 @@ class Enemy	: public Entity {
 public:
 	Enemy(EnemyType type) : m_type{ type } { }
 
+	EnemyType GetType() const {
+		return m_type;
+	}
+
 	bool IsAlive() const {
 		return m_alive;
 	}

EnemyFactory.cpp

@@ -0,0 +1,21 @@
+#include "EnemyFactory.h"
+#include "Enemy.h"
+#include <cassert>
+
+Enemy* CreateEnemy(EnemyType enemyType) {
+    Enemy* pEnemy = nullptr;
+
+    switch(enemyType) {
+        case EnemyType::Dragon:
+            pEnemy = new Enemy(EnemyType::Dragon);
+            break;
+        case EnemyType::Orc:
+            pEnemy = new Enemy(EnemyType::Orc);
+            break;
+        default:
+            assert(false); //Unknown enemy
+            break;
+    }
+
+    return pEnemy;
+}

EnemyFactory.h

@@ -0,0 +1,11 @@
+#pragma once
+
+class Enemy;
+
+enum class EnemyType {
+	Dragon,
+	Orc,
+	Max
+};
+
+Enemy* CreateEnemy(EnemyType enemyType);

EvaluateVisitor.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "Visitor.h"
+#include "Player.h"
+#include "Option.h"
+
+class EvaluateVisitor : public Visitor {
+private:
+    Player& m_player;
+
+public:
+    EvaluateVisitor(Player& player) : m_player { player } {}
+
+    virtual void OnVisit(Visitable& visitable) {
+        Option* pOption = dynamic_cast<Option*>(&visitable);
+
+        if(pOption != nullptr) {
+            pOption->Evaluate(m_player);
+        }
+    }
+};

Game.cpp

@@ -1,6 +1,7 @@
 #include "Game.h"
 #include "SDBMHash.h"
 #include "EventManager.h"
+#include "EvaluateVisitor.h"
 #include <iostream>
 #include <sstream>
 #include <cassert>
@@ -18,47 +19,64 @@ namespace {
 	constexpr int QuitEvent = SDBMCalculator<QuitEventStringLength>::CalculateValue(QuitEventString);
 }
 
-Game::Game() : m_attackDragonOption(&m_dragon, "Attack Dragon")
-	, m_attackOrcOption(&m_orc, "Attack Orc")
-	, m_moveNorthOption(Room::JoiningDirections::North, PlayerOptions::GoNorth, "Go North")
-	, m_moveEastOption(Room::JoiningDirections::East, PlayerOptions::GoEast, "Go East")
-	, m_moveSouthOption(Room::JoiningDirections::South, PlayerOptions::GoSouth, "Go South")
-	, m_moveWestOption(Room::JoiningDirections::West, PlayerOptions::GoWest, "Go West")
-	, m_openSwordChest(&m_swordChest, "Open Chest")
-	, m_quitOption("Quit")
-	, m_swordChest(&m_sword)
-	, m_dragon(Enemy::EnemyType::Dragon)
-	, m_orc(Enemy::EnemyType::Orc) { }
+Game::Game() 
+    : m_attackDragonOption{ CreateOption(PlayerOptions::AttackEnemy) }
+	, m_attackOrcOption{ CreateOption(PlayerOptions::AttackEnemy) }
+	, m_moveNorthOption{ CreateOption(PlayerOptions::GoNorth) }
+	, m_moveEastOption{ CreateOption(PlayerOptions::GoEast) }
+	, m_moveSouthOption{ CreateOption(PlayerOptions::GoSouth) }
+	, m_moveWestOption{ CreateOption(PlayerOptions::GoWest) }
+	, m_openSwordChest{ CreateOption(PlayerOptions::OpenChest) }
+	, m_quitOption{ CreateOption(PlayerOptions::Quit) }
+	, m_swordChest{ &m_sword } {
+        static_cast<OpenChestOption*>(m_openSwordChest.get())->SetChest(&m_swordChest);
+
+        m_enemies.emplace_back(CreateEnemy(EnemyType::Dragon));
+        static_cast<AttackEnemyOption*>(m_attackDragonOption.get())->SetEnemy(m_enemies[0]);
+
+        m_enemies.emplace_back(CreateEnemy(EnemyType::Orc));
+        static_cast<AttackEnemyOption*>(m_attackOrcOption.get())->SetEnemy(m_enemies[1]);
+
+        static_cast<QuitOption*>(m_quitOption.get())->AddObserver(this);
+}
+
+Game::~Game() {
+    static_cast<QuitOption*>(m_quitOption.get())->RemoveObserver(this);
+}
 
 void Game::InitializeRooms() {
-    //Room 0 heads North to Room 1
-    m_rooms[0].AddRoom(Room::JoiningDirections::North, &(m_rooms[1]));
-    m_rooms[0].AddStaticOption(&m_moveNorthOption);
-    m_rooms[0].AddStaticOption(&m_quitOption);
-    m_rooms[0].AddDynamicOption(&m_openSwordChest);
-
-    //Room 1 heads East to Room 2, South to Room 0 and West to Room 3
-    m_rooms[1].AddRoom(Room::JoiningDirections::East, &(m_rooms[2]));
-    m_rooms[1].AddStaticOption(&m_moveEastOption);
-    m_rooms[1].AddRoom(Room::JoiningDirections::South, &(m_rooms[0]));
-    m_rooms[1].AddStaticOption(&m_moveSouthOption);
-    m_rooms[1].AddRoom(Room::JoiningDirections::West, &(m_rooms[3]));
-    m_rooms[1].AddStaticOption(&m_moveWestOption);
-    m_rooms[1].AddStaticOption(&m_quitOption);
-
-    //Room 2 heads West to Room 1
-    m_rooms[2].AddRoom(Room::JoiningDirections::West, &(m_rooms[1]));
-    m_rooms[2].AddStaticOption(&m_moveWestOption);
-    m_rooms[2].AddStaticOption(&m_quitOption);
-    m_rooms[2].AddDynamicOption(&m_attackDragonOption);
-
-    //Room 3 heads East to Room 1
-    m_rooms[3].AddRoom(Room::JoiningDirections::East, &(m_rooms[1]));
-    m_rooms[3].AddStaticOption(&m_moveEastOption);
-    m_rooms[3].AddStaticOption(&m_quitOption);
-    m_rooms[3].AddDynamicOption(&m_attackOrcOption);
-
-    m_player.SetCurrentRoom(&(m_rooms[0]));
+	for (auto& roomPointer : m_rooms) {
+		roomPointer.reset(new Room());
+	}
+
+	// Room 0 heads North to Room 1
+	m_rooms[0]->AddRoom(Room::JoiningDirections::North, m_rooms[1]);
+	m_rooms[0]->AddStaticOption(m_moveNorthOption);
+	m_rooms[0]->AddStaticOption(m_quitOption);
+	m_rooms[0]->AddDynamicOption(m_openSwordChest);
+
+	// Room 1 heads East to Room 2, South to Room 0 and West to Room 3
+	m_rooms[1]->AddRoom(Room::JoiningDirections::East, m_rooms[2]);
+	m_rooms[1]->AddStaticOption(m_moveEastOption);
+	m_rooms[1]->AddRoom(Room::JoiningDirections::South, m_rooms[0]);
+	m_rooms[1]->AddStaticOption(m_moveSouthOption);
+	m_rooms[1]->AddRoom(Room::JoiningDirections::West, m_rooms[3]);
+	m_rooms[1]->AddStaticOption(m_moveWestOption);
+	m_rooms[1]->AddStaticOption(m_quitOption);
+
+	// Room 2 heads West to Room 1
+	m_rooms[2]->AddRoom(Room::JoiningDirections::West, m_rooms[1]);
+	m_rooms[2]->AddStaticOption(m_moveWestOption);
+	m_rooms[2]->AddStaticOption(m_quitOption);
+	m_rooms[2]->AddDynamicOption(m_attackDragonOption);
+
+	// Room 3 heads East to Room 1
+	m_rooms[3]->AddRoom(Room::JoiningDirections::East, m_rooms[1]);
+	m_rooms[3]->AddStaticOption(m_moveEastOption);
+	m_rooms[3]->AddStaticOption(m_quitOption);
+	m_rooms[3]->AddDynamicOption(m_attackOrcOption);
+
+	m_player.SetCurrentRoom(m_rooms[0]);
 }
 
 void Game::WelcomePlayer() {
@@ -91,21 +109,17 @@ PlayerOptions Game::EvaluateInput(stringstream& playerInputStream) {
     playerInputStream >> playerInputChoice;
 
     try {
-        Option* option = m_player.GetCurrentRoom()->EvaluateInput(playerInputChoice);
-        option->Evaluate(m_player);
-        chosenOption = option->GetChosenOption();
+        Option::Pointer option = m_player.GetCurrentRoom()->EvaluateInput(playerInputChoice);
+        EvaluateVisitor evaluator{ m_player };
+        option->Visit(evaluator);
     } catch(const out_of_range&){
         cout << "I do not recognize that option, try again!\n\n";
     }
 
     return chosenOption;
 }
 
-void Game::HandleEvent(const Event* pEvent) {
-    if(pEvent->GetID() == QuitEvent) {
-        m_playerQuit = true;
-    }
-}
+void Game::HandleEvent(const Event* pEvent) { }
 
 void Game::RunGame() {
     new EventManager();
@@ -126,7 +140,9 @@ void Game::RunGame() {
 
         EvaluateInput(playerInputStream);
 
-        playerWon = m_dragon.IsAlive() == false && m_orc.IsAlive() == false;
+        for(auto& enemy : m_enemies) {
+            playerWon = enemy->IsAlive() == false;
+        }
     }
 
     if(playerWon == true) {
@@ -138,4 +154,8 @@ void Game::RunGame() {
 
     DetachEvent(QuitEvent, this);
     delete EventManager::GetSingletonPtr();
+}
+
+void Game::OnQuit() {
+    m_playerQuit = true;
 }

Game.h

@@ -9,35 +9,34 @@
 #include "OpenChestOption.h"
 #include "Option.h"
 #include "Player.h"
-#include "PlayerOptions.h"
 #include "QuitOption.h"
 #include "Room.h"
 #include "Sword.h"
 #include <array>
 #include <map>
 
-class Game : public EventHandler {
+class Game : public EventHandler, public QuitObserver {
 private:
     static const unsigned int m_numberOfRooms = 4;
-    using Rooms = std::array<Room, m_numberOfRooms>;
-    Rooms m_rooms;
+	using Rooms = std::array<Room::Pointer, m_numberOfRooms>;
+	Rooms m_rooms;
 
     Player m_player;
 
-    AttackEnemyOption m_attackDragonOption;
-    AttackEnemyOption m_attackOrcOption;
-    MoveOption m_moveNorthOption;
-    MoveOption m_moveEastOption;
-    MoveOption m_moveSouthOption;
-    MoveOption m_moveWestOption;
-    OpenChestOption m_openSwordChest;
-    QuitOption m_quitOption;
+    Option::Pointer m_attackDragonOption;
+    Option::Pointer m_attackOrcOption;
+    Option::Pointer m_moveNorthOption;
+    Option::Pointer m_moveEastOption;
+    Option::Pointer m_moveSouthOption;
+    Option::Pointer m_moveWestOption;
+    Option::Pointer m_openSwordChest;
+    Option::Pointer m_quitOption;
 
     Sword m_sword;
     Chest m_swordChest;
 
-    Enemy m_dragon;
-    Enemy m_orc;
+    using Enemies = std::vector<Enemy::Pointer>;
+    Enemies m_enemies;
 
     bool m_playerQuit{ false };
 
@@ -49,8 +48,12 @@ class Game : public EventHandler {
 
 public:
     Game();
+    ~Game();
 
     void RunGame();
 
     virtual void HandleEvent(const Event* pEvent);
+
+    //From QuitObserver
+    virtual void OnQuit();
 };

MoveOption.cpp

@@ -3,8 +3,8 @@
 #include "MoveOption.h"
 
 void MoveOption::Evaluate(Player& player) {
-	const Room* pPlayerCurrentRoom = player.GetCurrentRoom();
-	Room* pNewRoom = pPlayerCurrentRoom->GetRoom(m_directionToMove);
+	const Room::Pointer pPlayerCurrentRoom = player.GetCurrentRoom();
+	Room::Pointer pNewRoom = pPlayerCurrentRoom->GetRoom(m_directionToMove);
 	if (pNewRoom != nullptr) {
 		player.SetCurrentRoom(pNewRoom);
 		std::cout << "You have chosen to " << m_outputText << "\n\n";