Line data    Source code

       1             : #include <shared.hpp>
       2             : 
       3             : #define TECH_LEVEL_1 3
       4             : #define TECH_LEVEL_2 6
       5             : #define TECH_LEVEL_3 10
       6             : #define TECH_LEVEL_4 14
       7             : #define TECH_LEVEL_5 19
       8             : #define TECH_LEVEL_END 24
       9             : #define TECH_LEVEL_RESET 17
      10             : 
      11             : using namespace shared;
      12             : 
      13          12 : Player::Player()
      14             : {
      15          12 :     connectedToSocket.store(false);
      16          12 :     std::fill(resources.begin(), resources.end(), 0);
      17          12 :     this->techLevel = 0;
      18          12 :     this->listOfPriorityCard[0] = std::make_shared<Card>(CardsEnum::economy, 1, 2);
      19          12 :     this->listOfPriorityCard[1] = std::make_shared<Card>(CardsEnum::military, 2, 4);
      20          12 :     this->listOfPriorityCard[2] = std::make_shared<Card>(CardsEnum::science, 3, 2);
      21          12 :     this->listOfPriorityCard[3] = std::make_shared<Card>(CardsEnum::culture, 4, 1);
      22          12 :     this->listOfPriorityCard[4] = std::make_shared<Card>(CardsEnum::industry, 5, 0);
      23          12 : }
      24             : 
      25           2 : Player::Player(std::string username)
      26             : {
      27           2 :     connectedToSocket.store(false);
      28           2 :     std::fill(resources.begin(), resources.end(), 0);
      29           2 :     this->techLevel = 0;
      30           2 :     this->username = username;
      31           2 :     this->listOfPriorityCard[0] = std::make_shared<Card>(CardsEnum::economy, 1, 2);
      32           2 :     this->listOfPriorityCard[1] = std::make_shared<Card>(CardsEnum::military, 2, 4);
      33           2 :     this->listOfPriorityCard[2] = std::make_shared<Card>(CardsEnum::science, 3, 2);
      34           2 :     this->listOfPriorityCard[3] = std::make_shared<Card>(CardsEnum::culture, 4, 1);
      35           2 :     this->listOfPriorityCard[4] = std::make_shared<Card>(CardsEnum::industry, 5, 0);
      36           2 : }
      37             : 
      38           6 : void Player::setUsername(std::string username)
      39             : {
      40           6 :     this->username = username;
      41           6 : }
      42             : 
      43           4 : void Player::setSocket(boost::asio::ip::tcp::socket &clientSocket)
      44             : {
      45           4 :     if (connectedToSocket.load())
      46             :     {
      47           0 :         disconnectPlayer();
      48             :     }
      49           4 :     connectedToSocket.store(true);
      50           4 :     this->playerSocket = std::make_shared<boost::asio::ip::tcp::socket>(std::move(clientSocket));
      51           4 : }
      52             : 
      53          30 : std::string Player::getName()
      54             : {
      55          30 :     return this->username;
      56             : }
      57             : 
      58           7 : std::array<int, 3> Player::incrementTechWheel(unsigned toIncrement)
      59             : {
      60             :     std::array<int, 3> result;
      61           7 :     std::fill(result.begin(), result.end(), 0);
      62         109 :     for (unsigned i = 0; i < toIncrement; i++)
      63             :     {
      64         102 :         this->techLevel += 1;
      65         102 :         if (this->techLevel == TECH_LEVEL_1 || this->techLevel == TECH_LEVEL_2)
      66             :         {
      67           8 :             result[0]++;
      68             :         }
      69          94 :         else if (this->techLevel == TECH_LEVEL_3 || this->techLevel == TECH_LEVEL_4)
      70             :         {
      71           8 :             result[1]++;
      72             :         }
      73          86 :         else if (this->techLevel == TECH_LEVEL_5 || this->techLevel == TECH_LEVEL_END)
      74             :         {
      75           8 :             result[2]++;
      76             :         }
      77         102 :         if (this->techLevel == TECH_LEVEL_END)
      78             :         {
      79           2 :             this->techLevel = TECH_LEVEL_RESET;
      80             :         }
      81             :     }
      82           7 :     return result;
      83             : }
      84             : 
      85          27 : unsigned Player::getLevelOfCard(CardsEnum cardType)
      86             : {
      87          80 :     for (auto card : this->listOfPriorityCard)
      88             :     {
      89          80 :         if (card->getType() == cardType)
      90             :         {
      91          27 :             return card->getLevel();
      92             :         }
      93          80 :     }
      94           0 :     return 0;
      95             : }
      96             : 
      97           6 : void Player::upgradeCard(CardsEnum cardType)
      98             : {
      99          36 :     for (auto card : this->listOfPriorityCard)
     100             :     {
     101          30 :         if (card->getType() == cardType)
     102             :         {
     103           6 :             card->addLevel();
     104             :         }
     105          30 :     }
     106           6 : }
     107             : 
     108           7 : void Player::addBox(CardsEnum cardType, unsigned numberOfBoxToAdd)
     109             : {
     110          42 :     for (auto card : this->listOfPriorityCard)
     111             :     {
     112          35 :         if (card->getType() == cardType)
     113             :         {
     114           7 :             card->addBox(numberOfBoxToAdd);
     115             :         }
     116          35 :     }
     117           7 : }
     118           0 : bool Player::operator==(Player &otherPlayer)
     119             : {
     120           0 :     return (this->getName() == otherPlayer.getName() &&
     121           0 :             connectedToSocket.load() == false &&
     122           0 :             otherPlayer.connectedToSocket.load() == false);
     123             : }
     124             : 
     125          48 : boost::asio::ip::tcp::socket &Player::getSocket()
     126             : {
     127          48 :     return *(this->playerSocket.get());
     128             : }
     129             : 
     130           0 : void Player::disconnectPlayer()
     131             : {
     132           0 :     connectedToSocket.store(false);
     133           0 :     std::lock_guard<std::mutex> socketLock(socketReadMutex);
     134           0 :     std::lock_guard<std::mutex> socketLock2(socketWriteMutex);
     135           0 :     if (playerSocket && playerSocket->is_open())
     136             :     {
     137           0 :         playerSocket->close();
     138             :     }
     139           0 :     playerSocket.reset();
     140           0 : }
     141             : 
     142           1 : std::vector<std::shared_ptr<Caravan>> Player::getCaravans()
     143             : {
     144           1 :     return this->listOfCaravan;
     145             : }
     146             : 
     147          13 : unsigned Player::getNumberOfBox(CardsEnum cardType)
     148             : {
     149          35 :     for (auto card : this->listOfPriorityCard)
     150             :     {
     151          35 :         if (card->getType() == cardType)
     152             :         {
     153          13 :             return card->getNumberOfBox();
     154             :         }
     155          35 :     }
     156           0 :     return 0;
     157             : }
     158             : 
     159           1 : void Player::addCaravan(std::shared_ptr<Caravan> newCaravan)
     160             : {
     161           1 :     this->listOfCaravan.push_back(newCaravan);
     162           1 : }
     163             : 
     164           1 : bool Player::haveResource(ResourceEnum resourceType)
     165             : {
     166           1 :     return this->resources[(int)resourceType] > 0;
     167             : }
     168             : 
     169           8 : void Player::addControlPawn(std::shared_ptr<ControlPawn> newControlPawn)
     170             : {
     171           8 :     this->listOfControlPawn.push_back(newControlPawn);
     172           8 : }
     173             : 
     174           2 : void Player::removeControlPawn(std::shared_ptr<ControlPawn> controlPawnToRemove)
     175             : {
     176           8 :     for (auto controlPawn : this->listOfControlPawn)
     177             :     {
     178           6 :         if (controlPawn == controlPawnToRemove)
     179             :         {
     180           0 :             this->listOfControlPawn.erase(std::remove(this->listOfControlPawn.begin(), this->listOfControlPawn.end(), controlPawnToRemove), this->listOfControlPawn.end());
     181             :         }
     182           6 :     }
     183           2 : }
     184             : 
     185           1 : void Player::addResource(ResourceEnum resourceType)
     186             : {
     187           1 :     this->resources[(int)resourceType] += 1;
     188           1 : }
     189             : 
     190           1 : unsigned Player::getTechLevel()
     191             : {
     192           1 :     return this->techLevel;
     193             : }
     194             : 
     195           2 : unsigned Player::getNumberOfResource(ResourceEnum resourceType)
     196             : {
     197           2 :     return this->resources[(int)resourceType];
     198             : }
     199             : 
     200           7 : void Player::deleteBox(CardsEnum cardType, unsigned numberOfBoxToDelete)
     201             : {
     202          42 :     for (auto card : this->listOfPriorityCard)
     203             :     {
     204          35 :         if (card->getType() == cardType)
     205             :         {
     206           7 :             card->deleteBox(numberOfBoxToDelete);
     207             :         }
     208          35 :     }
     209           7 : }
     210             : 
     211           2 : std::vector<std::shared_ptr<City>> Player::getCityList()
     212             : {
     213           2 :     return this->listOfCity;
     214             : }
     215             : 
     216           3 : void Player::addCity(std::shared_ptr<City> newCity)
     217             : {
     218           3 :     this->listOfCity.push_back(newCity);
     219           3 : }
     220             : 
     221           0 : std::vector<std::shared_ptr<ControlPawn>> Player::getControlPawns()
     222             : {
     223           0 :     return this->listOfControlPawn;
     224             : }
     225             : 
     226           0 : void Player::setDificultyOfCard(CardsEnum cardType, unsigned newDificulty)
     227             : {
     228           0 :     for (auto card : this->listOfPriorityCard)
     229             :     {
     230           0 :         if (card->getType() == cardType)
     231             :         {
     232           0 :             card->setDificulty(newDificulty);
     233             :         }
     234           0 :     }
     235           0 : }
     236             : 
     237          21 : unsigned Player::getDificultyOfCard(CardsEnum cardType)
     238             : {
     239          62 :     for (auto card : this->listOfPriorityCard)
     240             :     {
     241          62 :         if (card->getType() == cardType)
     242             :         {
     243          21 :             return card->getDificulty();
     244             :         }
     245          62 :     }
     246           0 :     return 0;
     247             : }
     248             : 
     249          11 : std::array<std::shared_ptr<Card>, 5> Player::getListOfPriorityCards()
     250             : {
     251          11 :     return this->listOfPriorityCard;
     252             : }