API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 18th, 2017
349
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 25.17 KB | None | 0 0
raw download clone embed print report
  1. // C++ Battle Text Game created by Justin Gonzales
  2. // Header.h
  3. #pragma once
  4. #include <iostream>
  5. #include <string>
  6. #include <vector>
  7. #include <memory>
  8. #include <random>
  9.  
  10. class GameEntity
  11. {
  12. protected:
  13.     const std::string m_name;
  14.     int m_hp;
  15. public:
  16.     GameEntity() {}
  17.     GameEntity(std::string name, int hp) : m_name(name), m_hp(hp){} // NOTE: Get() functions are
  18.         // justifyable under this hierchy
  19.     const std::string GetName() const { return m_name; }
  20.     const int GetHP() const { return m_hp;  }
  21.         // NOT VIRTUAL BECAUSE doesnt need to be changed
  22. };
  23.  
  24. struct Result
  25. {
  26.     Result() : m_energyCost(0), m_totalDamage(0), m_effect(nothing) {}
  27.     Result(const int energyCost, const int totalDamage, const int effect) : m_energyCost(energyCost), m_totalDamage(totalDamage)
  28.     {
  29.         switch (effect)
  30.         {
  31.         case 0:
  32.             m_effect = nothing;
  33.         case 1:
  34.             m_effect = fire;
  35.         case 2:
  36.             m_effect = freeze;
  37.         }
  38.     }
  39.  
  40.     bool Result::operator==(const Result result);
  41.  
  42.     enum Effect // local scope Effect enum
  43.     {
  44.         freeze,
  45.         fire,
  46.         nothing,
  47.     };
  48.  
  49.     const int m_energyCost;
  50.     const int m_totalDamage;
  51.     Effect m_effect;
  52. };
  53.  
  54. class Item : public GameEntity // NOTE: With polymorphism, the game will declare vectors to smart pointers'
  55.     // to Items. This allows functions to use an item as a weapon or item.
  56. {
  57. protected:
  58.     const std::shared_ptr<const Result> m_mainResult;
  59. public:
  60.     Item() {}
  61.     Item(std::string name, int hp, const Result mainResult) :
  62.         GameEntity(name, hp), m_mainResult(std::make_shared<const Result>(mainResult)) {}
  63.  
  64.     const int GetDurability() const;
  65.  
  66.     virtual std::shared_ptr<const Result> Use();
  67. };
  68.  
  69. class Weapon : public Item
  70. {
  71. private:
  72.     const std::shared_ptr<const Result> m_specialResult;
  73. public:
  74.     Weapon(std::string name, int hp, const Result mainResult, const Result specialResult):
  75.         Item(name, hp, mainResult), m_specialResult(std::make_shared<const Result>(specialResult)) {}
  76.  
  77.     virtual std::shared_ptr<const Result> Use(); // NOTE: Giving the Weapon this functionality might be a
  78.         // problem. The game will have to check if the item is a weapon or not to use the m_specail result.
  79.         // This goes against normal polymorphic practices. But since this is a very small game,
  80.         // I think we can sacrifice using dynamic_cast once.
  81. };
  82.  
  83. class OffensiveEntity : public GameEntity
  84. {
  85. protected:
  86.     std::vector< std::shared_ptr<Item> > m_items;
  87.     Result::Effect m_currentEffect;
  88. public:
  89.     OffensiveEntity(std::string name, int hp) : GameEntity(name, hp) {}
  90.  
  91.     void ClearItems();
  92.  
  93.     std::vector<std::shared_ptr<Item>> GetItems(std::vector<std::string> names) const;
  94.     std::vector<std::shared_ptr<Item>> GetItems() const;
  95.  
  96.     void AddItems(std::vector<std::shared_ptr<Item>> items);
  97.  
  98.     virtual void TakeResults(std::vector<std::shared_ptr<const Result>> results);
  99.  
  100.     virtual const int GetEnergy() const { return 0; } // These are here so the Player could work better with the Interface class
  101.  
  102.     virtual void SubtractEnergy(int sub) const { }
  103.  
  104.     virtual void Reset(); //NOTE: This class has a Reset function so it can be polymorphic with the Player class
  105.         // to be used in the interface classes. This function resets the current effect and changes the hp accordingly.
  106.         // The player function adds the added functionality of reseting the energy aswell.
  107. };
  108.  
  109. class Player : public OffensiveEntity // NOTE: Enemies are offensive entities because
  110.     // I couldn't find a difference between enemies and this base class.
  111.     // The player is different because he has energy.
  112. {
  113. private:
  114.     const int MAX_ENERGY = 10;
  115.     int m_currentEnergy;
  116. public:
  117.     Player(std::string name, int hp) : OffensiveEntity(name, hp),
  118.         m_currentEnergy(MAX_ENERGY) {}
  119.  
  120.     void TakeResults(std::vector<std::shared_ptr<const Result>> results);
  121.  
  122.     virtual const int GetEnergy() const { return m_currentEnergy; } // These are here so the Player could work better with the Interfave class
  123.  
  124.     virtual void SubtractEnergy(const int sub) { m_currentEnergy -= sub; }
  125.  
  126.     void Reset();
  127. };
  128.  
  129. class OffensiveEntityInterface
  130. {
  131. protected:
  132.     std::shared_ptr<OffensiveEntity> m_offensiveEntity;
  133. public:
  134.     OffensiveEntityInterface() {}
  135.  
  136.     OffensiveEntityInterface(std::string name, int hp)
  137.     { m_offensiveEntity = std::make_shared<OffensiveEntity>((OffensiveEntity(name, hp))); }
  138.  
  139.     OffensiveEntityInterface(OffensiveEntity o)
  140.     { m_offensiveEntity = std::make_shared<OffensiveEntity>(o); }
  141.  
  142.     virtual void Equip(std::vector<std::shared_ptr<Item>> items); // This function just calls AddItems()
  143.         // I don't know if that is invalid hierachercally, but it's the best idea when it comes to this
  144.         // class.
  145.  
  146.     std::vector<std::shared_ptr<Item>> GetEquiped() { return m_offensiveEntity->GetItems(); } // for debug reasons
  147.  
  148.     virtual std::vector<std::shared_ptr<const Result>> MakeNextDecisions() const = 0; // NOTE: Only pure virtual function because
  149.         // cannot have an implementaion for this base class. And will not need to create any of these objects.
  150. };
  151.  
  152. class EnemyAI : public OffensiveEntityInterface
  153. {
  154. private:
  155.     const int m_difficultyLevel; //NOTE: This variable is not in a class for Enemies for instance.
  156.  
  157.     // NOTE: These functions are private because nothing else needs to use them
  158.     std::shared_ptr<Item> CreateTempItem(std::string name, int hp, int mainEnergyCost, int mainTotalDamage, Result::Effect mainEffect) const;
  159.     std::shared_ptr<Item> CreateTempItem(std::string name, int hp, int mainEnergyCost, int mainTotalDamage, Result::Effect mainEffect, int specialEnergyCost,
  160.         int specialTotalDamage, Result::Effect specialEffect) const;
  161. public:
  162.     EnemyAI(std::string name, int hp, int difficulty) :
  163.         OffensiveEntityInterface(name, hp), m_difficultyLevel(difficulty) {} //NOTE: Calls OffensiveEntityInterface's constructor because
  164.             // Enemies are just OffensiveEntities
  165.     EnemyAI(OffensiveEntity o, int difficulty) : OffensiveEntityInterface(o), m_difficultyLevel(difficulty) {}
  166.  
  167.     virtual void Equip(); // NOTE: This gives the Enemy random weapons based on its dificulty level.
  168.  
  169.     std::vector<std::shared_ptr<const Result>> MakeNextDecisions() const; // NOTE: This function makes random choices on what weapons
  170.         // it will use in one turn based on the difficulty level. The enemy doesn't have energy because it is an uneeded complexity.
  171. };
  172.  
  173. class PlayerInterface : public OffensiveEntityInterface
  174. { // NOTE: Only class that doesn't have any added private member variables because it can use polymorphism to
  175.     // just reuse code. Specifically, realocating the offensiveEntity variable to a Player object.
  176. public:
  177.     PlayerInterface(std::string name, int hp)
  178.     {m_offensiveEntity = std::make_shared<Player>(Player(name, hp));}
  179.  
  180.     std::vector<std::shared_ptr<const Result>> MakeNextDecisions() const; // NOTE: this function prompts the user
  181.         // on what items to use and how much energy they have and what items they have chose to use.
  182.         // This is why it is redefined here.
  183. };
  184.  
  185. class Game
  186. {
  187. private:
  188.     std::vector<std::shared_ptr<EnemyAI>> m_enemies;
  189.     PlayerInterface m_player;
  190.  
  191. };
  192.  
  193. // Main.cpp. Test file
  194. #include "Header.h"
  195.  
  196. int main()
  197. {
  198.     std::shared_ptr<EnemyAI> offensiveEntityInterface =
  199.         std::make_shared<EnemyAI>(EnemyAI("Dank Memerson", 50, 1));
  200.     std::vector<std::shared_ptr<Item>> tempItems;
  201.     tempItems.push_back(std::make_shared<Item>(Item("Dank Doodles", 20, Result(2, 40, Result::Effect::freeze))));
  202.     tempItems.push_back(std::make_shared<Item>(Item("Dank Doodlea", 36, Result(4, 56, Result::Effect::fire))));
  203.     offensiveEntityInterface->OffensiveEntityInterface::Equip(tempItems);
  204.     for (auto & i : offensiveEntityInterface->GetEquiped())
  205.     {
  206.         std::cout << i->GetName() << " name \n";
  207.         std::cout << i->GetHP() << " durability \n";
  208.         std::shared_ptr<const Result> tempResult = i->Use();
  209.         std::cout << tempResult->m_totalDamage << " total damage \n";
  210.         std::cout << tempResult->m_energyCost << " energy cost \n";
  211.         std::cout << tempResult->m_effect << " effect \n";
  212.     }
  213.     offensiveEntityInterface->Equip();
  214.     for (auto & i : offensiveEntityInterface->GetEquiped())
  215.     {
  216.         std::cout << i->GetName() << " name \n";
  217.         std::cout << i->GetHP() << " durability \n";
  218.         std::shared_ptr<const Result> tempResult = i->Use();
  219.         std::cout << tempResult->m_totalDamage << " total damage \n";
  220.         std::cout << tempResult->m_energyCost << " energy cost \n";
  221.         std::cout << tempResult->m_effect << " effect \n";
  222.     }
  223.     std::cin.get();
  224.     return 0;
  225. }
  226.  
  227. // MemberDefinitions.h
  228. #include "Header.h"
  229.  
  230. // random number generator from Stroustrup:
  231. // http://www.stroustrup.com/C++11FAQ.html#std-random
  232. template<class T>
  233. T rand_num(const T & low, const T & high)
  234. {
  235.     static std::default_random_engine re{};
  236.     using Dist = std::uniform_int_distribution<T>;
  237.     static Dist uid{};
  238.     return uid(re, Dist::param_type{ low,high });
  239. }
  240.  
  241. //Result definitions
  242. bool Result::operator==(const Result result)
  243. {
  244.     if ((result.m_effect == m_effect) || (result.m_energyCost == m_energyCost)
  245.         || (result.m_totalDamage == m_totalDamage))
  246.         return true;
  247.     else
  248.         return false;
  249. }
  250.  
  251. //Item definitions
  252. std::shared_ptr<const Result> Item::Use()
  253. {
  254.     if ((m_hp != 0) && (m_hp > 0))
  255.     {
  256.         m_hp -= m_mainResult->m_energyCost;
  257.         return std::make_shared<const Result>(*m_mainResult);
  258.     }
  259.     else
  260.     {
  261.         return std::make_shared<const Result>(0, 0, 0);
  262.     }
  263. }
  264.  
  265. const int Item::GetDurability() const
  266. {
  267.     return m_hp;
  268. }
  269.  
  270. //Weapon definitions
  271. std::shared_ptr<const Result> Weapon::Use()
  272. {
  273.     bool special = false;
  274.     if (rand_num<int>(1, 3) == 2)
  275.         special = false;
  276.     else
  277.         special = true;
  278.  
  279.     if ((m_hp != 0) && (m_hp > 0))
  280.     {
  281.         if (special == true)
  282.         {
  283.             m_hp -= m_specialResult->m_energyCost;
  284.             return std::make_shared<const Result>(*m_specialResult);
  285.         }
  286.         else
  287.         {
  288.             m_hp -= m_mainResult->m_energyCost;
  289.             return std::make_shared<const Result>(*m_mainResult);
  290.         }
  291.     }
  292.     else
  293.         return std::make_shared<const Result>(0, 0, 0);
  294. }
  295.  
  296. //OffensiveEntity definitions
  297.  
  298. void OffensiveEntity::ClearItems()
  299. {
  300.     m_items.clear();
  301. }
  302.  
  303. // Iterates through items to find if their name is the same as the names specified
  304. std::vector<std::shared_ptr<Item>> OffensiveEntity::GetItems(std::vector<std::string> names) const
  305. {
  306.     std::vector<std::shared_ptr<Item>> items;
  307.  
  308.     for (const std::shared_ptr<Item> & i : m_items)
  309.     {
  310.         for (std::string j : names)
  311.         {
  312.             if (i->GetName() == j) // Checks if name is equal
  313.                 items.push_back(std::make_shared<Item>(*i)); // Assigns item to vector
  314.         }
  315.     }
  316.     return items;
  317. }
  318.  
  319. std::vector<std::shared_ptr<Item>>  OffensiveEntity::GetItems() const
  320. {
  321.     return m_items;
  322. }
  323.  
  324. void OffensiveEntity::AddItems(std::vector<std::shared_ptr<Item>> items)
  325. {
  326.     for (auto & i : items)
  327.     {
  328.         m_items.push_back(std::make_shared<Item>(*i));
  329.     }
  330. }
  331.  
  332. void OffensiveEntity::TakeResults(std::vector<std::shared_ptr<const Result>> results)
  333. {
  334.     for (auto & i : results)
  335.     {
  336.         m_hp -= i->m_totalDamage;
  337.         m_currentEffect = i->m_effect;
  338.     }
  339. }
  340.  
  341. void OffensiveEntity::Reset()
  342. {
  343.     switch (m_currentEffect)
  344.     {
  345.     case (Result::Effect::freeze):
  346.         m_hp -= 10;
  347.  
  348.         m_currentEffect = Result::Effect::nothing;
  349.         break;
  350.     case (Result::Effect::fire):
  351.         m_hp -= 20;
  352.  
  353.         m_currentEffect = Result::Effect::nothing;
  354.         break;
  355.     }
  356. }
  357.  
  358. //Player definitions
  359.  
  360. void Player::Reset()
  361. {
  362.     int oldHp = m_hp;
  363.     m_currentEnergy = MAX_ENERGY;
  364.     OffensiveEntity::Reset();
  365.     switch (m_currentEffect)
  366.     {
  367.     case (Result::Effect::freeze):
  368.         m_currentEnergy -= 3;
  369.         break;
  370.     case (Result::Effect::fire):
  371.         m_currentEnergy -= 1;
  372.         break;
  373.     }
  374.     std::cout << "You received " << oldHp - m_hp << " damage from current effect\n";
  375. }
  376.  
  377. void Player::TakeResults(std::vector<std::shared_ptr<const Result>> results)
  378. {
  379.     int oldHp = m_hp;
  380.     OffensiveEntity::TakeResults(results);
  381.     for (const std::shared_ptr<const Result> & i : results)
  382.     {
  383.         m_currentEnergy -= i->m_energyCost;
  384.     }
  385.     std::cout << "You received " << oldHp - m_hp << " damage\n";
  386. }
  387.  
  388. //OffensiveEntityInterface definitions
  389.  
  390. void OffensiveEntityInterface::Equip(std::vector<std::shared_ptr<Item>> items)
  391. {
  392.     m_offensiveEntity->AddItems(items);
  393. }
  394.  
  395. //EnemyAI definitions
  396.  
  397. std::shared_ptr<Item> EnemyAI::CreateTempItem(std::string name, int hp, int mainEnergyCost, int mainTotalDamage, Result::Effect mainEffect) const
  398. {
  399.     std::shared_ptr<const Result> tempResult = std::make_shared<const Result>(mainEnergyCost, mainTotalDamage, mainEffect);
  400.     std::shared_ptr<Item> tempItem = std::make_shared<Item>(name, hp, *tempResult);
  401.     return std::make_shared<Item>(*tempItem);
  402. }
  403.  
  404. std::shared_ptr<Item> EnemyAI::CreateTempItem(std::string name, int hp, int mainEnergyCost, int mainTotalDamage, Result::Effect mainEffect, int specialEnergyCost,
  405.     int specialTotalDamage, Result::Effect specialEffect) const
  406. {
  407.     std::shared_ptr<const Result> tempMainResult = std::make_shared<const Result>(mainEnergyCost, mainTotalDamage, mainEffect);
  408.  
  409.     std::shared_ptr<const Result> tempSpecialResult = std::make_shared<const Result>(specialEnergyCost, specialTotalDamage, specialEffect);
  410.  
  411.     std::shared_ptr<Item> tempItem = std::make_shared<Weapon>(Weapon(name, hp, *tempMainResult, *tempSpecialResult));
  412.     return std::make_shared<Item>(*tempItem);
  413. }
  414.  
  415. //  This function assigns different names and different levels for different
  416. //  weapons and items. These items are then assigned to the m_items member variable.
  417. //  Values are hard coded because I didn't know how to use any kind of parser like xml.
  418. void EnemyAI::Equip()
  419. {
  420.     m_offensiveEntity->ClearItems();
  421.  
  422.     std::vector<std::shared_ptr<Item>> tempItems;
  423.  
  424.     int tempRandom = 0;
  425.  
  426.     switch (m_difficultyLevel)
  427.     {
  428.     case 0:
  429.     case 1:
  430.     {
  431.         tempRandom = rand_num<int>(2, 4);
  432.         if ((tempRandom == 1) || (tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4))
  433.             tempItems.push_back(CreateTempItem("Health Potion : HP", 3, 3, -10, Result::Effect::nothing));
  434.         if (tempRandom == 3)
  435.             tempItems.push_back(CreateTempItem("Wooden Stick : DMG", 5, 2, 10, Result::Effect::nothing, 3, 13, Result::Effect::nothing));
  436.         break;
  437.     }
  438.     case 2:
  439.     {
  440.         tempRandom = rand_num<int>(1, 4);
  441.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4))
  442.             tempItems.push_back(CreateTempItem("Health Potion : HP", 3, 3, -15, Result::Effect::nothing));
  443.         if ((tempRandom == 3) || (tempRandom == 4))
  444.             tempItems.push_back(CreateTempItem("Slightly Better Wooden Stick : DMG", 5, 2, 12, Result::Effect::nothing, 3, 15, Result::Effect::nothing));
  445.         if (tempRandom == 2)
  446.             tempItems.push_back(CreateTempItem("Mini Knife : DMG", 3, 1, 7, Result::Effect::nothing, 2, 11, Result::Effect::nothing));
  447.         break;
  448.     }
  449.     case 3:
  450.     {
  451.         tempRandom = rand_num<int>(1, 5);
  452.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5))
  453.             tempItems.push_back(CreateTempItem("Freeze Potion : SPLL", 3, 3, 4, Result::Effect::freeze));
  454.         if ((tempRandom == 2) || (tempRandom == 3))
  455.             tempItems.push_back(CreateTempItem("Wooden Sword : DMG", 5, 2, 16, Result::Effect::nothing, 3, 27, Result::Effect::nothing));
  456.         if (tempRandom == 4)
  457.             tempItems.push_back(CreateTempItem("Rock : DMG", 4, 1, 12, Result::Effect::nothing));
  458.         if ((tempRandom == 2) || (tempRandom == 5))
  459.             tempItems.push_back(CreateTempItem("Steak : HP", 2, 2, -20, Result::Effect::nothing));
  460.         break;
  461.     }
  462.     case 4:
  463.     {
  464.         tempRandom = rand_num<int>(1, 6);
  465.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5) || (tempRandom == 6))
  466.             tempItems.push_back(CreateTempItem("Fire Potion : SPLL", 3, 3, 10, Result::Effect::fire));
  467.         if ((tempRandom == 3) || (tempRandom == 4))
  468.             tempItems.push_back(CreateTempItem("Frozen Wooden Sword : DMG", 4, 3, 16, Result::Effect::freeze, 4, 27, Result::Effect::nothing));
  469.         if (tempRandom == 4)
  470.             tempItems.push_back(CreateTempItem("Broom on Fire : DMG", 1, 1, 13, Result::Effect::fire));
  471.         if ((tempRandom == 5) || (tempRandom == 6))
  472.             tempItems.push_back(CreateTempItem("Magic Potato : HP", 2, 2, -20, Result::Effect::nothing));
  473.         if ((tempRandom == 7))
  474.             tempItems.push_back(CreateTempItem("Stone Sword : DMG", 6, 2, 21, Result::Effect::nothing, 3, 32, Result::Effect::nothing));
  475.         break;
  476.     }
  477.     case 5:
  478.     {
  479.         tempRandom = rand_num<int>(1, 6);
  480.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5) || (tempRandom == 6))
  481.         {
  482.             tempItems.push_back(CreateTempItem("Super Health Potion : HP", 3, 3, -20, Result::Effect::nothing));
  483.             tempItems.push_back(CreateTempItem("Stone Sword : DMG", 6, 3, 21, Result::Effect::nothing, 4, 32, Result::Effect::nothing));
  484.         }
  485.         if ((tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5))
  486.         {
  487.             tempItems.push_back(CreateTempItem("Stone Sword: DMG", 6, 3, 21, Result::Effect::nothing, 4, 32, Result::Effect::nothing));
  488.             tempItems.push_back(CreateTempItem("Stone Sword: DMG", 6, 3, 21, Result::Effect::nothing, 4, 32, Result::Effect::nothing));
  489.         }
  490.         if (tempRandom == 4)
  491.             tempItems.push_back(CreateTempItem("Freeze Potion: SPLL", 3, 3, 15, Result::Effect::freeze));
  492.         if ((tempRandom == 2))
  493.             tempItems.push_back(CreateTempItem("Iron Rod : DMG", 2, 2, 20, Result::Effect::fire));
  494.         if ((tempRandom == 6))
  495.             tempItems.push_back(CreateTempItem("Large Steak : HP", 2, 2, -26, Result::Effect::nothing));
  496.         break;
  497.     }
  498.     case 6:
  499.     {
  500.         tempRandom = rand_num<int>(1, 6);
  501.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5) || (tempRandom == 6))
  502.         {
  503.             tempItems.push_back(CreateTempItem("Super Health Potion : HP", 2, 2, -20, Result::Effect::nothing));
  504.             tempItems.push_back(CreateTempItem("Iron Rod : DMG", 2, 2, 20, Result::Effect::fire));
  505.         }
  506.         if ((tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5))
  507.         {
  508.             tempItems.push_back(CreateTempItem("Stone Sword: DMG", 7, 3, 27, Result::Effect::nothing, 4, 39, Result::Effect::nothing));
  509.             tempItems.push_back(CreateTempItem("Stone Sword: DMG", 7, 3, 27, Result::Effect::nothing, 4, 39, Result::Effect::nothing));
  510.         }
  511.         if (tempRandom == 4)
  512.         {
  513.             tempItems.push_back(CreateTempItem("Fire Potion: SPLL", 3, 3, 21, Result::Effect::fire));
  514.             tempItems.push_back(CreateTempItem("Freeze Potion: SPLL", 3, 3, 11, Result::Effect::freeze));
  515.         }
  516.         if ((tempRandom == 2))
  517.             tempItems.push_back(CreateTempItem("Fired Up Stone Sword : DMG", 7, 3, 27, Result::Effect::nothing, 4, 39, Result::Effect::nothing));
  518.         if ((tempRandom == 6))
  519.             tempItems.push_back(CreateTempItem("Large Steak : HP", 2, 2, -30, Result::Effect::nothing));
  520.         break;
  521.     }
  522.     case 7:
  523.     {
  524.         tempRandom = rand_num<int>(1, 7);
  525.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5) || (tempRandom == 6) || (tempRandom == 7))
  526.             tempItems.push_back(CreateTempItem("Super Health Potion : HP", 2, 2, -20, Result::Effect::nothing));
  527.         if ((tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5))
  528.             tempItems.push_back(CreateTempItem("Iron Sword: DMG", 9, 3, 34, Result::Effect::nothing, 4, 51, Result::Effect::nothing));
  529.         if (tempRandom == 4)
  530.         {
  531.             tempItems.push_back(CreateTempItem("Fire Potion: SPLL", 3, 3, 31, Result::Effect::fire));
  532.             tempItems.push_back(CreateTempItem("Freeze Potion: SPLL", 3, 3, 24, Result::Effect::freeze));
  533.         }
  534.         if ((tempRandom == 2))
  535.             tempItems.push_back(CreateTempItem("Pearl Rod : DMG", 2, 2, 44, Result::Effect::nothing));
  536.         if ((tempRandom == 6))
  537.             tempItems.push_back(CreateTempItem("WaterShroom : HP", 2, 2, -37, Result::Effect::nothing));
  538.         if ((tempRandom == 7))
  539.             tempItems.push_back(CreateTempItem("Summon Slash : SPLL", 3, 3, 61, Result::Effect::nothing));
  540.         break;
  541.     }
  542.     case 10:
  543.     {
  544.         tempRandom = rand_num<int>(1, 7);
  545.         if ((tempRandom == 2) || (tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5) || (tempRandom == 6) || (tempRandom == 7))
  546.         {
  547.             tempItems.push_back(CreateTempItem("Super Health Potion : HP", 2, 2, -20, Result::Effect::nothing));
  548.             tempItems.push_back(CreateTempItem("Eye of Diamond : SPLL", 2, 2, 34, Result::Effect::freeze));
  549.         }
  550.         if ((tempRandom == 3) || (tempRandom == 4) || (tempRandom == 5) || (tempRandom == 6))
  551.             tempItems.push_back(CreateTempItem("Steel Sword: DMG", 11, 3, 51, Result::Effect::nothing, 4, 76, Result::Effect::nothing));
  552.         if (tempRandom == 4)
  553.         {
  554.             tempItems.push_back(CreateTempItem("Fire Potion: SPLL", 3, 3, 31, Result::Effect::fire));
  555.             tempItems.push_back(CreateTempItem("Fire Potion: SPLL", 3, 3, 31, Result::Effect::fire));
  556.             tempItems.push_back(CreateTempItem("Freeze Potion: SPLL", 3, 3, 24, Result::Effect::freeze));
  557.         }
  558.         if ((tempRandom == 2))
  559.         {
  560.             tempItems.push_back(CreateTempItem("Diamond Rod : DMG", 2, 2, 87, Result::Effect::nothing));
  561.             tempItems.push_back(CreateTempItem("Steel Sword on Fire: DMG", 11, 3, 42, Result::Effect::fire, 4, 76, Result::Effect::fire));
  562.         }
  563.         if ((tempRandom == 6))
  564.         {
  565.             tempItems.push_back(CreateTempItem("WaterShroom : HP", 2, 2, -37, Result::Effect::nothing));
  566.             tempItems.push_back(CreateTempItem("Large Steak : HP", 2, 2, -30, Result::Effect::nothing));
  567.             tempItems.push_back(CreateTempItem("Large Steak : HP", 2, 2, -30, Result::Effect::nothing));
  568.         }
  569.         if ((tempRandom == 7))
  570.         {
  571.             tempItems.push_back(CreateTempItem("Diamond Blade: DMG", 13, 3, 91, Result::Effect::nothing, 4, 127, Result::Effect::nothing));
  572.         }
  573.         break;
  574.     }
  575.     }
  576.  
  577.     m_offensiveEntity->AddItems(tempItems);
  578. }
  579.  
  580. std::vector< std::shared_ptr<const Result> > EnemyAI::MakeNextDecisions() const
  581. {
  582.     std::vector< std::shared_ptr<const Result> > finalResults;
  583.     std::vector<std::string> names;
  584.  
  585.     struct itemType
  586.     {
  587.         int number;
  588.         std::string findString;
  589.     };
  590.  
  591.     std::vector<struct itemType> itemTypes;
  592.     itemTypes.push_back({1, ": HP"});
  593.     itemTypes.push_back({1, ": DMG"});
  594.     itemTypes.push_back({1, ": SPLL"});
  595.  
  596.     switch (rand_num<int>(1, 4)) // Picks a random number
  597.     {
  598.     case 2://this determines the number the difficulty level will be divided by that
  599.         //determines the num of that item
  600.         for (itemType i : itemTypes)
  601.         {
  602.             if (i.findString == ": HP")
  603.                 i.number = 2;
  604.             else if (i.findString == ": DMG")
  605.                 i.number = 4;
  606.             else if (i.findString == ": SPLL")
  607.                 i.number = 5;
  608.         }
  609.     case 3:
  610.         for (itemType i : itemTypes)
  611.         {
  612.             if (i.findString == ": HP")
  613.                 i.number = 5;
  614.             else if (i.findString == ": DMG")
  615.                 i.number = 4;
  616.             else if (i.findString == ": SPLL")
  617.                 i.number = 2;
  618.         }
  619.     case 4:
  620.         for (itemType i : itemTypes)
  621.         {
  622.             if (i.findString == ": HP")
  623.                 i.number = 4;
  624.             else if (i.findString == ": DMG")
  625.                 i.number = 2;
  626.             else if (i.findString == ": SPLL")
  627.                 i.number = 5;
  628.         }
  629.     }
  630.    
  631.    
  632.     for (itemType j : itemTypes)
  633.     {
  634.         for (int k = 0; k < (m_difficultyLevel / j.number); k++) // This determines the amount of items it will use
  635.         {
  636.             for (const std::shared_ptr<Item> & i : m_offensiveEntity->GetItems()) // This block of code goes through all possible items
  637.             {
  638.                 for (std::string j : names) // finds name that equals item name
  639.                 {
  640.                     if (j == i->GetName()) // if item name already in list continue
  641.                         continue;
  642.                 }
  643.                 if (i->GetName().find(j.findString)) // It finds an name that is in the specified Item
  644.                 {
  645.                     if ((i->Use() == std::make_shared<const Result>(0, 0, 0)) != false) // checks if item has no more durability
  646.                     {
  647.                         finalResults.push_back(std::make_shared<Result>(*(i->Use()))); // NOTE: Special is never specified because Weapon.Use() picks randomly
  648.                         names.push_back(i->GetName());
  649.                     }
  650.                 }
  651.             }
  652.         }
  653.     }
  654.     std::cout << "Its the enmies turn! The enemy attacks with items: \n";
  655.     for (std::string i : names)
  656.         std::cout << " : " << i;
  657.     std::cout << "\n";
  658.     return finalResults;
  659. }
  660.  
  661. //PlayerInterface definitions
  662.  
  663. std::vector < std::shared_ptr<const Result> > PlayerInterface::MakeNextDecisions() const
  664. {
  665.     std::vector < std::shared_ptr<const Result> > finalResults; // vector that will be returned
  666.     std::vector <std::string> names; // names of items currently using durring turn
  667.  
  668.     std::cout << "Its your turn! What items will you use?/n";
  669.     std::cout << "Current items in pouch:\n";
  670.     for (std::shared_ptr<Item> & i : m_offensiveEntity->GetItems()) // prints out all items
  671.         std::cout << " : " << i->GetName();
  672.     while (true)
  673.     {
  674.         std::cout << "Current energy: " << m_offensiveEntity->GetEnergy();
  675.         if ((m_offensiveEntity->GetEnergy() == 0) || (m_offensiveEntity->GetEnergy() < 0)) // breaks if no more energy
  676.         {
  677.             std::cout << "No more energy";
  678.             break;
  679.         }
  680.         std::cout << "\nCurrent items chosen: ";
  681.         for (std::string i : names)
  682.         {
  683.             std::cout << " : " << i;
  684.         }
  685.  
  686.         std::cout << " \nDo you want to use another item? 1 Yes and 2 No.\n";
  687.         int input;
  688.         std::cin >> input;
  689.         if (input == 2)
  690.             break;
  691.  
  692.         std::string temp;
  693.         std::cout << "\n Enter Item: ";
  694.         std::getline(std::cin, temp);
  695.         for (std::string i : names) // loops through names. if name already there than continues to next prompt
  696.         {
  697.             if (temp == i)
  698.             {
  699.                 std::cout << "Item already chosen";
  700.                 continue;
  701.             }
  702.         }
  703.         for (const std::shared_ptr<Item> & i : m_offensiveEntity->GetItems())
  704.         {
  705.             if (i->GetName() == temp)
  706.             {
  707.                 if (i->Use() == std::make_shared<const Result>(Result(0, 0, 0)))
  708.                 {
  709.                     std::cout << "Item broken. Try again.";
  710.                     break;
  711.                 }
  712.                 finalResults.push_back(std::make_shared<Result>(*(i->Use())));
  713.                 m_offensiveEntity->SubtractEnergy(i->Use()->m_energyCost);
  714.                 names.push_back(i->GetName());
  715.                 continue;
  716.             }
  717.            
  718.         }
  719.         std::cout << "Item not found. Please try again.";
  720.     }
  721.     int totalDamage = 0;
  722.     std::cout << "Total damage: ";
  723.     for (std::shared_ptr<const Result> & i : finalResults)
  724.     {
  725.         totalDamage += i->m_totalDamage;
  726.     }
  727.     std::cout << totalDamage;
  728.     return finalResults;
  729. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!