joadson

Game.cpp

Jan 13th, 2021
689
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. bool Game::playerLeaveMarket(uint32_t playerId)
  2. {
  3.     Player* player = getPlayerByID(playerId);
  4.     if(!player || player->isRemoved())
  5.         return false;
  6.  
  7.     player->setMarketDepotId(-1);
  8.     player->setInMarket(false);
  9.     return true;
  10. }
  11.  
  12. bool Game::playerBrowseMarket(uint32_t playerId, uint16_t spriteId)
  13. {
  14.     Player* player = getPlayerByID(playerId);
  15.     if(!player || player->isRemoved())
  16.         return false;
  17.  
  18.     if ((getMoney(player) > 2000000000)) {
  19.         return false;
  20.     }  
  21.    
  22.     const ItemType& it = Item::items.getItemIdByClientId(spriteId);
  23.     if(it.id == 0)
  24.         return false;
  25.  
  26.     const MarketOfferList& buyOffers = IOMarket::getInstance()->getActiveOffers(MARKETACTION_BUY);
  27.     const MarketOfferList& sellOffers = IOMarket::getInstance()->getActiveOffers(MARKETACTION_SELL);
  28.     player->sendMarketBrowseItem(it.id, buyOffers, sellOffers);
  29.     player->sendMarketDetail(it.id);
  30.     return true;
  31. }
  32.  
  33. bool Game::playerBrowseMarketOwnOffers(uint32_t playerId)
  34. {
  35.     Player* player = getPlayerByID(playerId);
  36.     if(!player || player->isRemoved())
  37.         return false;
  38.  
  39.     if (getMoney(player) > 2000000000) {
  40.         return false;
  41.     }  
  42.    
  43.     const MarketOfferList& buyOffers = IOMarket::getInstance()->getOwnOffers(MARKETACTION_BUY, player->getGUID());
  44.     const MarketOfferList& sellOffers = IOMarket::getInstance()->getOwnOffers(MARKETACTION_SELL, player->getGUID());
  45.     player->sendMarketBrowseOwnOffers(buyOffers, sellOffers);
  46.     return true;
  47. }
  48.  
  49. bool Game::playerBrowseMarketOwnHistory(uint32_t playerId)
  50. {
  51.     Player* player = getPlayerByID(playerId);
  52.     if(!player || player->isRemoved())
  53.         return false;
  54.    
  55.     if (!player->isInMarket()) {
  56.         return false;
  57.     }
  58.  
  59.     const HistoryMarketOfferList& buyOffers = IOMarket::getInstance()->getOwnHistory(MARKETACTION_BUY, player->getGUID());
  60.     const HistoryMarketOfferList& sellOffers = IOMarket::getInstance()->getOwnHistory(MARKETACTION_SELL, player->getGUID());
  61.     player->sendMarketBrowseOwnHistory(buyOffers, sellOffers);
  62.     return true;
  63. }
  64.  
  65. bool Game::playerItemDescMarket(uint32_t playerId, uint32_t timestamp, uint16_t counter)
  66. {
  67.     Player* player = getPlayerByID(playerId);
  68.     if(!player || player->isRemoved())
  69.         return false;
  70.    
  71.     uint32_t offerId = IOMarket::getInstance()->getOfferIdByCounter(timestamp, counter);
  72.     if(offerId == 0)
  73.         return false;
  74.    
  75.     MarketOfferEx offer = IOMarket::getInstance()->getOfferById(offerId);
  76.     const ItemType& it = Item::items[offer.itemId];
  77.     Item* item = Item::CreateItem(it.id, -1);
  78.     std::stringstream test(offer.Attrs);
  79.     std::string segment;
  80.     std::vector<std::string> seglist;
  81.     if(offer.Attrs != "false"){
  82.         while(std::getline(test, segment, 'º'))
  83.         {
  84.             seglist.push_back(segment);
  85.         }
  86.         for(int i = 0; i < seglist.size(); i++) {
  87.             std::stringstream test2(seglist[i]);
  88.             std::string segment2;
  89.             std::vector<std::string> seglist2;
  90.             while(std::getline(test2, segment2, '#'))
  91.             {
  92.                 seglist2.push_back(segment2);
  93.             }
  94.             if(std::isdigit(atoi((char*)seglist2[1].c_str())) || atoi((char*)seglist2[1].c_str()) >= 1){
  95.                 item->setAttribute(seglist2[0], atoi((char*)seglist2[1].c_str()));
  96.             }else{
  97.                 item->setAttribute(seglist2[0], seglist2[1]);
  98.             }
  99.         }
  100.     }
  101.     if(item->hasStringAttribute("description")){
  102.         player->sendMarketItemDesc(item->getSpecialDescription(), offer.itemId);
  103.     }else{
  104.         player->sendMarketItemDesc(item->getDescription(1), offer.itemId);
  105.     }
  106.     delete item;
  107.     return true;
  108. }
  109.  
  110. bool Game::playerCreateMarketOffer(uint32_t playerId, uint8_t type, const Position& pos, int16_t stackpos, uint16_t spriteId, uint16_t amount, uint32_t price, bool anonymous)
  111. {
  112.    
  113.     if(amount == 0 || amount > 100)
  114.         return false;
  115.  
  116.     if(price < 0 || price > 999999999)
  117.         return false;
  118.  
  119.     if(type != MARKETACTION_BUY && type != MARKETACTION_SELL)
  120.         return false;
  121.  
  122.     Player* player = getPlayerByID(playerId);
  123.     if(!player || player->isRemoved())
  124.         return false;
  125.    
  126.     if (!player->isInMarket()) {
  127.         return false;
  128.     }
  129.        
  130.     if (getMoney(player) > 2000000000) {
  131.         return false;
  132.     }      
  133.    
  134.     const int32_t maxOfferCount = 100;
  135.     if(maxOfferCount > 0)
  136.     {
  137.         const int32_t offerCount = IOMarket::getInstance()->getPlayerOfferCount(player->getGUID());
  138.         if(offerCount == -1 || offerCount >= maxOfferCount)
  139.             return false;
  140.     }
  141.  
  142.     uint64_t fee = (price / 100.) * amount;
  143.     if(fee < 20)
  144.         fee = 20;
  145.        
  146.     std::stringstream parseAttrs;
  147.     Thing* thing = internalGetThing(player, pos, stackpos, spriteId, STACKPOS_NORMAL);
  148.    
  149.     if(!thing)
  150.         return false;  
  151.    
  152.     Item* item = thing->getItem();
  153.     if(!item)
  154.         return false;
  155.        
  156.     if(item->hasStringAttribute("unique"))
  157.         return false;
  158.        
  159.     if(item->hasBooleanAttribute("unique"))
  160.         return false;
  161.  
  162.     if(type == MARKETACTION_SELL)
  163.     {
  164.         if(fee > getMoney(player))
  165.             return false;
  166.  
  167.         uint32_t count = item->getItemCount();
  168.         if (amount > count)
  169.             return false;
  170.            
  171.         std::string Attrs[] = {"poke", "nick", "memory", "xHeldItem", "megaID", "copyName", "SmeargleID", "addon", "ball", "yHeldItem","reverseIcon","gender", "boost", "happy", "hp", "transBegin", "hunger", "transLeft", "transTurn", "transOutfit", "transName", "trans", "light", "blink", "move1", "move2", "move3", "move4", "move5", "move6", "move7", "move8", "move9", "move10", "move11", "move12", "ballorder", "hands", "aura", "burn", "burndmg", "poison", "poisondmg", "confuse", "sleep", "miss", "missSpell", "missEff", "fear", "fearSkill", "silence", "silenceEff", "stun", "stunEff", "stunSpell", "paralyze", "paralyzeEff", "slow", "slowEff", "leech", "leechdmg", "Buff1", "Buff2", "Buff3", "Buff1skill","Buff2skill", "Buff3skill", "control", "task", "lock"};
  172.         bool first = true;
  173.         for (int i = 0; i < ((sizeof Attrs) / (sizeof Attrs[0])); i++)
  174.         {
  175.             std::string sep = "";
  176.             if(i != ((sizeof Attrs) / (sizeof Attrs[0]))){
  177.                 sep = "º";
  178.             }
  179.            
  180.             if(item->hasIntegerAttribute(Attrs[i])){
  181.                 const int32_t* value = ((item)->getIntegerAttribute(Attrs[i]));
  182.                 parseAttrs << Attrs[i] << "#" << *value << sep ;
  183.             }
  184.            
  185.             if(item->hasStringAttribute(Attrs[i])){
  186.                 const std::string* value = ((item)->getStringAttribute(Attrs[i]));
  187.                 parseAttrs << Attrs[i] << "#" << *value << sep ;
  188.             }
  189.            
  190.             if(item->hasBooleanAttribute(Attrs[i])){
  191.                 const bool* value = ((item)->getBooleanAttribute(Attrs[i]));
  192.                 parseAttrs << Attrs[i] << "#" << *value << sep ;
  193.             }
  194.            
  195.             if(item->hasFloatAttribute(Attrs[i])){
  196.                 const float* value = ((item)->getFloatAttribute(Attrs[i]));
  197.                 parseAttrs << Attrs[i] << "#" << *value << sep ;
  198.             }
  199.  
  200.         }  
  201.                                        
  202.         if(item->isStackable())
  203.         {
  204.             internalRemoveItem(NULL, item, amount);
  205.         }
  206.         else
  207.         {              
  208.             internalRemoveItem(NULL, item->getItem());
  209.         }
  210.         removeMoney(player, fee);
  211.     }
  212.     else
  213.     {
  214.         uint64_t totalPrice = (uint64_t)price * amount;
  215.         totalPrice += fee;
  216.         parseAttrs << false;
  217.         if(totalPrice > getMoney(player))
  218.             return false;
  219.        
  220.         removeMoney(player, totalPrice);
  221.     }
  222.    
  223.     IOMarket::getInstance()->createOffer(player->getGUID(), (MarketAction_t)type, item->getID(), amount, price, anonymous,  parseAttrs.str());
  224.  
  225.     player->sendMarketEnter(1);
  226.     const MarketOfferList& buyOffers = IOMarket::getInstance()->getActiveOffers(MARKETACTION_BUY);
  227.     const MarketOfferList& sellOffers = IOMarket::getInstance()->getActiveOffers(MARKETACTION_SELL);
  228.     player->sendMarketBrowseItem(item->getID(), buyOffers, sellOffers);
  229.     return true;
  230. }
  231.  
  232. bool Game::playerCancelMarketOffer(uint32_t playerId, uint32_t timestamp, uint16_t counter)
  233. {
  234.     Player* player = getPlayerByID(playerId);
  235.     if(!player || player->isRemoved())
  236.         return false;
  237.     Depot* depotChest = player->getDepot(2, false);
  238.  
  239.     uint32_t offerId = IOMarket::getInstance()->getOfferIdByCounter(timestamp, counter);
  240.     if(offerId == 0)
  241.         return false;
  242.  
  243.     MarketOfferEx offer = IOMarket::getInstance()->getOfferById(offerId);
  244.     if(offer.playerId != player->getGUID())
  245.         return false;
  246.        
  247.     if(offer.type == MARKETACTION_BUY)
  248.     {
  249.         addMoney(player->getDepot(2, false), (uint64_t)offer.price * offer.amount, FLAG_NOLIMIT);
  250.         player->sendMarketEnter(1);
  251.     }
  252.     else
  253.     {
  254.         const ItemType& it = Item::items[offer.itemId];
  255.         if(it.id == 0)
  256.             return false;
  257.  
  258.         if(it.stackable)
  259.         {
  260.             uint16_t tmpAmount = offer.amount;
  261.             while(tmpAmount > 0)
  262.             {
  263.                 int32_t stackCount = std::min<int32_t>(100, tmpAmount);
  264.                 Item* item = Item::CreateItem(it.id, stackCount);
  265.                 if(internalAddItem(NULL, depotChest, item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  266.                 {
  267.                     delete item;
  268.                     break;
  269.                 }
  270.  
  271.                 tmpAmount -= stackCount;
  272.             }
  273.         }
  274.         else
  275.         {
  276.             int32_t subType = -1;
  277.             if(it.charges != 0)
  278.                 subType = it.charges;
  279.  
  280.             for(uint16_t i = 0; i < offer.amount; ++i)
  281.             {
  282.                 Item* item = Item::CreateItem(it.id, subType);
  283.                 std::stringstream test(offer.Attrs);
  284.                 std::string segment;
  285.                 std::vector<std::string> seglist;
  286.                 if(offer.Attrs != "false" && subType == -1){
  287.                     while(std::getline(test, segment, 'º'))
  288.                     {
  289.                         seglist.push_back(segment);
  290.                     }
  291.                     for(int i = 0; i < seglist.size(); i++) {
  292.                         std::stringstream test2(seglist[i]);
  293.                         std::string segment2;
  294.                         std::vector<std::string> seglist2;
  295.                         while(std::getline(test2, segment2, '#'))
  296.                         {
  297.                             seglist2.push_back(segment2);
  298.                         }
  299.                         if(std::isdigit(atoi((char*)seglist2[1].c_str())) || atoi((char*)seglist2[1].c_str()) >= 1){
  300.                             item->setAttribute(seglist2[0], atoi((char*)seglist2[1].c_str()));
  301.                         }else{
  302.                             item->setAttribute(seglist2[0], seglist2[1]);
  303.                         }
  304.                     }
  305.                 }
  306.                 if(internalAddItem(NULL, depotChest, item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  307.                 {
  308.                     delete item;
  309.                     break;
  310.                 }
  311.             }
  312.         }
  313.     }
  314.  
  315.     IOMarket::getInstance()->moveOfferToHistory(offerId, OFFERSTATE_CANCELLED);
  316.     offer.amount = 0;
  317.     offer.timestamp += (30 * 24 * 60 * 60);
  318.     player->sendMarketCancelOffer(offer);
  319.     return true;
  320. }
  321.  
  322. bool Game::playerAcceptMarketOffer(uint32_t playerId, uint32_t timestamp, uint16_t counter, uint16_t amount)
  323. {
  324.     if(amount == 0 || amount > 100)
  325.         return false;
  326.  
  327.     Player* player = getPlayerByID(playerId);
  328.     if(!player || player->isRemoved())
  329.         return false;
  330.  
  331.     uint32_t offerId = IOMarket::getInstance()->getOfferIdByCounter(timestamp, counter);
  332.     if(offerId == 0)
  333.         return false;
  334.        
  335.     if (!player->isInMarket()) {
  336.         return false;
  337.     }
  338.        
  339.     if (getMoney(player) > 2000000000) {
  340.         return false;
  341.     }        
  342.  
  343.     MarketOfferEx offer = IOMarket::getInstance()->getOfferById(offerId);
  344.     if(amount > offer.amount)
  345.         return false;
  346.        
  347.     if(offer.price == 0)
  348.         return false;
  349.  
  350.     const ItemType& it = Item::items[offer.itemId];
  351.     if(it.id == 0)
  352.         return false;
  353.  
  354.     uint64_t totalPrice = (uint64_t)offer.price * amount;
  355.     if(offer.type == MARKETACTION_BUY)
  356.     {
  357.         Depot* depotChest = player->getDepot(2, false);
  358.         if(!depotChest)
  359.             return false;
  360.  
  361.         ItemList itemList;
  362.         uint32_t count = 0;
  363.         std::list<Container*> containerList;
  364.         containerList.push_back(depotChest);
  365.         bool enough = false;
  366.         do
  367.         {
  368.             Container* container = containerList.front();
  369.             containerList.pop_front();
  370.             for(ItemList::const_iterator iter = container->getItems(), end = container->getEnd(); iter != end; ++iter)
  371.             {
  372.                 Item* item = (*iter);
  373.                 Container* c = item->getContainer();
  374.                 if(c && !c->empty())
  375.                 {
  376.                     containerList.push_back(c);
  377.                     continue;
  378.                 }
  379.  
  380.                 if(item->getID() != it.id)
  381.                     continue;
  382.  
  383.                 const ItemType& itemType = Item::items[item->getID()];
  384.                 if(!itemType.isRune() && item->getCharges() != itemType.charges)
  385.                     continue;
  386.  
  387.                 if(item->getDuration() != itemType.decayTime)
  388.                     continue;
  389.  
  390.                 itemList.push_back(item);
  391.                 count += Item::countByType(item, -1);
  392.                 if(count >= amount)
  393.                 {
  394.                     enough = true;
  395.                     break;
  396.                 }
  397.             }
  398.  
  399.             if(enough)
  400.                 break;
  401.         }
  402.         while(!containerList.empty());
  403.  
  404.         if(!enough)
  405.             return false;
  406.  
  407.         if(it.stackable)
  408.         {
  409.             uint16_t tmpAmount = amount;
  410.             for(ItemList::const_iterator iter = itemList.begin(), end = itemList.end(); iter != end; ++iter)
  411.             {
  412.                 uint16_t removeCount = std::min(tmpAmount, (*iter)->getItemCount());
  413.                 tmpAmount -= removeCount;
  414.                 internalRemoveItem(NULL,*iter, removeCount);
  415.                 if(tmpAmount == 0)
  416.                     break;
  417.             }
  418.         }
  419.         else
  420.         {
  421.             for(ItemList::const_iterator iter = itemList.begin(), end = itemList.end(); iter != end; ++iter)
  422.                 internalRemoveItem(NULL,*iter);
  423.         }
  424.  
  425.         addMoney(player->getDepot(2, true), totalPrice, FLAG_NOLIMIT);
  426.        
  427.         Player* buyerPlayer = getPlayerByGuid(offer.playerId);
  428.         if(!buyerPlayer)
  429.         {
  430.             std::string buyerName;
  431.             if(!IOLoginData::getInstance()->getNameByGuid(offer.playerId, buyerName))
  432.                 return false;
  433.  
  434.             buyerPlayer = new Player(buyerName, NULL);
  435.             if(!IOLoginData::getInstance()->loadPlayer(buyerPlayer, buyerName))
  436.             {
  437.                 delete buyerPlayer;
  438.                 return false;
  439.             }
  440.         }
  441.  
  442.         if(it.stackable)
  443.         {
  444.             uint16_t tmpAmount = amount;
  445.             while(tmpAmount > 0)
  446.             {
  447.                 uint16_t stackCount = std::min<uint16_t>(100, tmpAmount);
  448.                 Item* item = Item::CreateItem(it.id, stackCount);                      
  449.                 if(internalAddItem(NULL, buyerPlayer->getDepot(2, false), item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  450.                 {
  451.                     delete item;
  452.                     break;
  453.                 }
  454.  
  455.                 tmpAmount -= stackCount;
  456.             }
  457.         }
  458.         else
  459.         {
  460.             int32_t subType = -1;
  461.             if(it.charges != 0)
  462.                 subType = it.charges;
  463.            
  464.             for(uint16_t i = 0; i < amount; ++i)
  465.             {
  466.                 Item* item = Item::CreateItem(it.id, subType);
  467.                 std::stringstream test(offer.Attrs);
  468.                 std::string segment;
  469.                 std::vector<std::string> seglist;
  470.                 if(offer.Attrs != "false" && subType == -1){
  471.                     while(std::getline(test, segment, 'º'))
  472.                     {
  473.                         seglist.push_back(segment);
  474.                     }
  475.                     for(int i = 0; i < seglist.size(); i++) {
  476.                         std::stringstream test2(seglist[i]);
  477.                         std::string segment2;
  478.                         std::vector<std::string> seglist2;
  479.                         while(std::getline(test2, segment2, '#'))
  480.                         {
  481.                             seglist2.push_back(segment2);
  482.                         }
  483.                         if(std::isdigit(atoi((char*)seglist2[1].c_str())) || atoi((char*)seglist2[1].c_str()) >= 1){
  484.                             item->setAttribute(seglist2[0], atoi((char*)seglist2[1].c_str()));
  485.                         }else{
  486.                             item->setAttribute(seglist2[0], seglist2[1]);
  487.                         }
  488.                     }
  489.                 }
  490.                
  491.                 if(internalAddItem(NULL, buyerPlayer->getDepot(2, false), item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  492.                 {
  493.                     delete item;
  494.                     break;
  495.                 }
  496.             }
  497.         }
  498.  
  499.         if(buyerPlayer->isOffline())
  500.         {
  501.             IOLoginData::getInstance()->savePlayer(buyerPlayer);
  502.             delete buyerPlayer;
  503.         }
  504.         else
  505.             buyerPlayer->onReceiveMail();
  506.     }
  507.     else
  508.     {
  509.         if(totalPrice > getMoney(player))
  510.             return false;
  511.  
  512.         removeMoney(player, totalPrice);
  513.  
  514.         if(it.stackable)
  515.         {
  516.             uint16_t tmpAmount = amount;
  517.             while(tmpAmount > 0)
  518.             {
  519.                 uint16_t stackCount = std::min<uint16_t>(100, tmpAmount);
  520.                 Item* item = Item::CreateItem(it.id, stackCount);
  521.                 Depot* depotChest = player->getDepot(2, false);
  522.                 if(internalAddItem(NULL, depotChest, item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  523.                 {
  524.                     delete item;
  525.                     break;
  526.                 }
  527.  
  528.                 tmpAmount -= stackCount;
  529.             }
  530.         }
  531.         else
  532.         {
  533.             int32_t subType = -1;
  534.             if(it.charges != 0)
  535.                 subType = it.charges;
  536.  
  537.             for(uint16_t i = 0; i < amount; ++i)
  538.             {
  539.                 Item* item = Item::CreateItem(it.id, subType);
  540.                 Depot* depotChest = player->getDepot(2, false);
  541.                 std::stringstream test(offer.Attrs);
  542.                 std::string segment;
  543.                 std::vector<std::string> seglist;
  544.                 if(offer.Attrs != "false" && subType == -1){
  545.                     while(std::getline(test, segment, 'º'))
  546.                     {
  547.                         seglist.push_back(segment);
  548.                     }
  549.                     for(int i = 0; i < seglist.size(); i++) {
  550.                         std::stringstream test2(seglist[i]);
  551.                         std::string segment2;
  552.                         std::vector<std::string> seglist2;
  553.                         while(std::getline(test2, segment2, '#'))
  554.                         {
  555.                             seglist2.push_back(segment2);
  556.                         }
  557.                         if(std::isdigit(atoi((char*)seglist2[1].c_str())) || atoi((char*)seglist2[1].c_str()) >= 1){
  558.                             item->setAttribute(seglist2[0], atoi((char*)seglist2[1].c_str()));
  559.                         }else{
  560.                             item->setAttribute(seglist2[0], seglist2[1]);
  561.                         }
  562.                     }
  563.                 }
  564.                
  565.                 if(internalAddItem(NULL, depotChest, item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  566.                 {
  567.                     delete item;
  568.                     break;
  569.                 }
  570.                 else{
  571.                     player->onReceiveMail();
  572.                 }
  573.             }
  574.         }
  575.  
  576.         Player* sellerPlayer = getPlayerByGuid(offer.playerId);
  577.         if(sellerPlayer)
  578.             addMoney(sellerPlayer->getDepot(2, true), totalPrice);
  579.         else{
  580.             std::string sellerName;
  581.             if(!IOLoginData::getInstance()->getNameByGuid(offer.playerId, sellerName))
  582.                 return false;
  583.            
  584.             int32_t money = totalPrice;
  585.             IntegerMap teste = Item::items.getMoneyMap();
  586.             int32_t tmp = 0;
  587.             for(IntegerMap::reverse_iterator it = teste.rbegin(); it != teste.rend(); ++it)
  588.             {
  589.                 tmp = money / it->first;
  590.                 money -= tmp * it->first;
  591.                 if(tmp != 0)
  592.                 {
  593.                     do
  594.                     {
  595.                         Item* remaindItem = Item::CreateItem(it->second-1, std::min(100, tmp));
  596.                         IOLoginData::getInstance()->playerMail(player, sellerName, 2, remaindItem);
  597.                                
  598.                         tmp -= std::min(100, tmp);
  599.                     }
  600.                     while(tmp > 0);
  601.                 }
  602.             }
  603.         }
  604.  
  605.         player->onReceiveMail();
  606.     }
  607.  
  608.     const int32_t marketOfferDuration = (30 * 24 * 60 * 60);
  609.     IOMarket::getInstance()->appendHistory(player->getGUID(), (offer.type == MARKETACTION_BUY ? MARKETACTION_SELL : MARKETACTION_BUY), offer.itemId, amount, offer.price, offer.timestamp + marketOfferDuration, OFFERSTATE_ACCEPTEDEX, offer.Attrs);
  610.     IOMarket::getInstance()->appendHistory(offer.playerId, offer.type, offer.itemId, amount, offer.price, offer.timestamp + marketOfferDuration, OFFERSTATE_ACCEPTED, offer.Attrs);
  611.  
  612.     offer.amount -= amount;
  613.     if(offer.amount == 0)
  614.         IOMarket::getInstance()->deleteOffer(offerId);
  615.     else
  616.         IOMarket::getInstance()->acceptOffer(offerId, amount);
  617.  
  618.     player->sendMarketEnter(1);
  619.     offer.timestamp += marketOfferDuration;
  620.     player->sendMarketAcceptOffer(offer);
  621.     return true;
  622. }
  623.  
  624. void Game::checkExpiredMarketOffers()
  625. {
  626.     IOMarket::getInstance()->clearOldHistory();
  627.     const ExpiredMarketOfferList& expiredBuyOffers = IOMarket::getInstance()->getExpiredOffers(MARKETACTION_BUY);
  628.     for(ExpiredMarketOfferList::const_iterator it = expiredBuyOffers.begin(), end = expiredBuyOffers.end(); it != end; ++it)
  629.     {
  630.         ExpiredMarketOffer offer = *it;
  631.  
  632.         Player* player = getPlayerByGuid(offer.playerId);
  633.         uint64_t totalPrice = (uint64_t)offer.price * offer.amount;
  634.         if(player)
  635.             addMoney(player->getDepot(2, false), totalPrice, FLAG_NOLIMIT);
  636.         else
  637.             IOLoginData::getInstance()->increaseBankBalance(offer.playerId, totalPrice);
  638.  
  639.         IOMarket::getInstance()->moveOfferToHistory(offer.id, OFFERSTATE_EXPIRED);
  640.     }
  641.  
  642.     const ExpiredMarketOfferList& expiredSellOffers = IOMarket::getInstance()->getExpiredOffers(MARKETACTION_SELL);
  643.     for(ExpiredMarketOfferList::const_iterator it = expiredSellOffers.begin(), end = expiredSellOffers.end(); it != end; ++it)
  644.     {
  645.         ExpiredMarketOffer offer = *it;
  646.  
  647.         Player* player = getPlayerByGuid(offer.playerId);
  648.         if(!player)
  649.         {
  650.             std::string name;
  651.             if(!IOLoginData::getInstance()->getNameByGuid(offer.playerId, name))
  652.                 continue;
  653.  
  654.             player = new Player(name, NULL);
  655.             if(!IOLoginData::getInstance()->loadPlayer(player, name))
  656.             {
  657.                 delete player;
  658.                 continue;
  659.             }
  660.         }
  661.  
  662.         const ItemType& itemType = Item::items[offer.itemId];
  663.         Depot* depotChest = player->getDepot(2, false);
  664.         if(itemType.id == 0)
  665.             continue;
  666.  
  667.         if(itemType.stackable)
  668.         {
  669.             uint16_t tmpAmount = offer.amount;
  670.             while(tmpAmount > 0)
  671.             {
  672.                 uint16_t stackCount = std::min<uint16_t>(100, tmpAmount);
  673.                 Item* item = Item::CreateItem(itemType.id, stackCount);
  674.                 if(internalAddItem(NULL, depotChest, item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  675.                 {
  676.                     delete item;
  677.                     break;
  678.                 }
  679.                 else{
  680.                     player->onReceiveMail();
  681.                 }
  682.  
  683.                 tmpAmount -= stackCount;
  684.             }
  685.         }
  686.         else
  687.         {
  688.             int32_t subType = -1;
  689.             if(itemType.charges != 0)
  690.                 subType = itemType.charges;
  691.  
  692.             for(uint16_t i = 0; i < offer.amount; ++i)
  693.             {
  694.                 Item* item = Item::CreateItem(itemType.id, subType);
  695.                 MarketOfferEx offer2 = IOMarket::getInstance()->getOfferById(offer.id);
  696.                 std::stringstream test(offer2.Attrs);
  697.                 std::string segment;
  698.                 std::vector<std::string> seglist;
  699.                 if(offer2.Attrs != "false" && subType == -1){
  700.                     while(std::getline(test, segment, 'º'))
  701.                     {
  702.                         seglist.push_back(segment);
  703.                     }
  704.                     for(int i = 0; i < seglist.size(); i++) {
  705.                         std::stringstream test2(seglist[i]);
  706.                         std::string segment2;
  707.                         std::vector<std::string> seglist2;
  708.                         while(std::getline(test2, segment2, '#'))
  709.                         {
  710.                             seglist2.push_back(segment2);
  711.                         }
  712.                         if(std::isdigit(atoi((char*)seglist2[1].c_str())) || atoi((char*)seglist2[1].c_str()) >= 1){
  713.                             item->setAttribute(seglist2[0], atoi((char*)seglist2[1].c_str()));
  714.                         }else{
  715.                             item->setAttribute(seglist2[0], seglist2[1]);
  716.                         }
  717.                     }
  718.                 }
  719.                 if(internalAddItem(NULL, depotChest, item, INDEX_WHEREEVER, FLAG_NOLIMIT) != RET_NOERROR)
  720.                 {
  721.                     delete item;
  722.                     break;
  723.                 }
  724.             }
  725.         }
  726.  
  727.         if(player->isOffline())
  728.         {
  729.             IOLoginData::getInstance()->savePlayer(player);
  730.             delete player;
  731.         }
  732.  
  733.         IOMarket::getInstance()->moveOfferToHistory(offer.id, OFFERSTATE_EXPIRED);
  734.     }
  735.  
  736.     int32_t checkExpiredMarketOffersEachMinutes = 30;
  737.     if(checkExpiredMarketOffersEachMinutes <= 0)
  738.         return;
  739.  
  740.     Scheduler::getInstance().addEvent(createSchedulerTask(checkExpiredMarketOffersEachMinutes * 60 * 1000, boost::bind(&Game::checkExpiredMarketOffers, this)));
  741. }
  742.  
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×