joadson

Game.cpp

Jan 13th, 2021
648
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