//does not clear ram
void AuctionHouseMgr::SendAuctionWonMail(AuctionEntry* auction, SQLTransaction& trans)
{
Item* pItem = GetAItem(auction->itemGUIDLow);
if (!pItem)
return;
uint32 bidderAccId = 0;
ObjectGuid bidderGuid(HighGuid::Player, auction->bidder);
Player* bidder = ObjectAccessor::FindConnectedPlayer(bidderGuid);
// data for gm.log
std::string bidderName;
bool logGmTrade = false;
if (bidder)
{
bidderAccId = bidder->GetSession()->GetAccountId();
bidderName = bidder->GetName();
logGmTrade = bidder->GetSession()->HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE);
}
else
{
bidderAccId = sObjectMgr->GetPlayerAccountIdByGUID(bidderGuid);
logGmTrade = AccountMgr::HasPermission(bidderAccId, rbac::RBAC_PERM_LOG_GM_TRADE, realmID);
if (logGmTrade && !sObjectMgr->GetPlayerNameByGUID(bidderGuid, bidderName))
bidderName = sObjectMgr->GetTrinityStringForDBCLocale(LANG_UNKNOWN);
}
if (logGmTrade)
{
ObjectGuid ownerGuid = ObjectGuid(HighGuid::Player, auction->owner);
std::string ownerName;
if (!sObjectMgr->GetPlayerNameByGUID(ownerGuid, ownerName))
ownerName = sObjectMgr->GetTrinityStringForDBCLocale(LANG_UNKNOWN);
uint32 ownerAccId = sObjectMgr->GetPlayerAccountIdByGUID(ownerGuid);
sLog->outCommand(bidderAccId, "GM %s (Account: %u) won item in auction: %s (Entry: %u Count: %u) and pay money: %u. Original owner %s (Account: %u)",
bidderName.c_str(), bidderAccId, pItem->GetTemplate()->Name1.c_str(), pItem->GetEntry(), pItem->GetCount(), auction->bid, ownerName.c_str(), ownerAccId);
}
// receiver exist
if (bidder || bidderAccId)
{
// set owner to bidder (to prevent delete item with sender char deleting)
// owner in `data` will set at mail receive and item extracting
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_OWNER);
stmt->setUInt32(0, auction->bidder);
stmt->setUInt32(1, pItem->GetGUID().GetCounter());
trans->Append(stmt);
if (bidder)
{
bidder->GetSession()->SendAuctionBidderNotification(auction->GetHouseId(), auction->Id, bidderGuid, 0, 0, auction->itemEntry);
// FIXME: for offline player need also
bidder->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_WON_AUCTIONS, 1);
}
MailDraft(auction->BuildAuctionMailSubject(AUCTION_WON), AuctionEntry::BuildAuctionMailBody(auction->owner, auction->bid, auction->buyout, 0, 0))
.AddItem(pItem)
.SendMailTo(trans, MailReceiver(bidder, auction->bidder), auction, MAIL_CHECK_MASK_COPIED);
}
else
{
// bidder doesn't exist, delete the item
sAuctionMgr->RemoveAItem(auction->itemGUIDLow, true);
}
}
//this void creates new auction and adds auction to some auctionhouse
void WorldSession::HandleAuctionSellItem(WorldPacket& recvData)
{
ObjectGuid auctioneer;
uint32 itemsCount, etime, bid, buyout;
recvData >> auctioneer;
recvData >> itemsCount;
ObjectGuid itemGUIDs[MAX_AUCTION_ITEMS]; // 160 slot = 4x 36 slot bag + backpack 16 slot
uint32 count[MAX_AUCTION_ITEMS];
memset(count, 0, sizeof(count));
if (itemsCount > MAX_AUCTION_ITEMS)
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
recvData.rfinish();
return;
}
for (uint32 i = 0; i < itemsCount; ++i)
{
recvData >> itemGUIDs[i];
recvData >> count[i];
if (!itemGUIDs[i] || !count[i] || count[i] > 1000)
{
recvData.rfinish();
return;
}
}
recvData >> bid;
recvData >> buyout;
recvData >> etime;
if (!bid || !etime)
return;
if (bid > MAX_MONEY_AMOUNT || buyout > MAX_MONEY_AMOUNT)
{
TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Player %s (GUID %u) attempted to sell item with higher price than max gold amount.", _player->GetName().c_str(), _player->GetGUID().GetCounter());
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
if (!creature)
{
TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit (%s) not found or you can't interact with him.", auctioneer.ToString().c_str());
return;
}
AuctionHouseEntry const* auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(creature->getFaction());
if (!auctionHouseEntry)
{
TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit (%s) has wrong faction.", auctioneer.ToString().c_str());
return;
}
etime *= MINUTE;
switch (etime)
{
case 1*MIN_AUCTION_TIME:
case 2*MIN_AUCTION_TIME:
case 4*MIN_AUCTION_TIME:
break;
default:
return;
}
if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
Item* items[MAX_AUCTION_ITEMS];
uint32 finalCount = 0;
uint32 itemEntry = 0;
for (uint32 i = 0; i < itemsCount; ++i)
{
Item* item = _player->GetItemByGuid(itemGUIDs[i]);
if (!item)
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_ITEM_NOT_FOUND);
return;
}
if (itemEntry == 0)
itemEntry = item->GetTemplate()->ItemId;
if (sAuctionMgr->GetAItem(item->GetGUID().GetCounter()) || !item->CanBeTraded() || item->IsNotEmptyBag() ||
item->GetTemplate()->Flags & ITEM_PROTO_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION) ||
item->GetCount() < count[i] || itemEntry != item->GetTemplate()->ItemId)
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
items[i] = item;
finalCount += count[i];
}
if (!finalCount)
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
// check if there are 2 identical guids, in this case user is most likely cheating
for (uint32 i = 0; i < itemsCount - 1; ++i)
{
for (uint32 j = i + 1; j < itemsCount; ++j)
{
if (itemGUIDs[i] == itemGUIDs[j])
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
}
}
for (uint32 i = 0; i < itemsCount; ++i)
{
Item* item = items[i];
if (item->GetMaxStackCount() < finalCount)
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
}
Item* item = items[0];
uint32 auctionTime = uint32(etime * sWorld->getRate(RATE_AUCTION_TIME));
AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
uint32 deposit = sAuctionMgr->GetAuctionDeposit(auctionHouseEntry, etime, item, finalCount);
if (!_player->HasEnoughMoney(deposit))
{
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGHT_MONEY);
return;
}
AuctionEntry* AH = new AuctionEntry();
if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
AH->houseId = AUCTIONHOUSE_NEUTRAL;
else
{
CreatureData const* auctioneerData = sObjectMgr->GetCreatureData(creature->GetSpawnId());
if (!auctioneerData)
{
TC_LOG_ERROR("misc", "Data for auctioneer not found (%s)", auctioneer.ToString().c_str());
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
delete AH;
return;
}
CreatureTemplate const* auctioneerInfo = sObjectMgr->GetCreatureTemplate(auctioneerData->id);
if (!auctioneerInfo)
{
TC_LOG_ERROR("misc", "Non existing auctioneer (%s)", auctioneer.ToString().c_str());
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
delete AH;
return;
}
const AuctionHouseEntry* AHEntry = sAuctionMgr->GetAuctionHouseEntry(auctioneerInfo->faction);
AH->houseId = AHEntry->houseId;
}
// Required stack size of auction matches to current item stack size, just move item to auctionhouse
if (itemsCount == 1 && item->GetCount() == count[0])
{
if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
{
sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
GetPlayerName().c_str(), GetAccountId(), item->GetTemplate()->Name1.c_str(), item->GetEntry(), item->GetCount());
}
AH->Id = sObjectMgr->GenerateAuctionID();
AH->itemGUIDLow = item->GetGUID().GetCounter();
AH->itemEntry = item->GetEntry();
AH->itemCount = item->GetCount();
AH->owner = _player->GetGUID().GetCounter();
AH->startbid = bid;
AH->bidder = 0;
AH->bid = 0;
AH->buyout = buyout;
AH->expire_time = time(NULL) + auctionTime;
AH->deposit = deposit;
AH->etime = etime;
AH->auctionHouseEntry = auctionHouseEntry;
TC_LOG_INFO("network", "CMSG_AUCTION_SELL_ITEM: Player %s (guid %d) is selling item %s entry %u (guid %d) with count %u with initial bid %u with buyout %u and with time %u (in sec) in auctionhouse %u",
_player->GetName().c_str(), _player->GetGUID().GetCounter(), item->GetTemplate()->Name1.c_str(), item->GetEntry(), item->GetGUID().GetCounter(), item->GetCount(), bid, buyout, auctionTime, AH->GetHouseId());
sAuctionMgr->AddAItem(item);
auctionHouse->AddAuction(AH);
sAuctionMgr->PendingAuctionAdd(_player, AH);
_player->MoveItemFromInventory(item->GetBagSlot(), item->GetSlot(), true);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
item->DeleteFromInventoryDB(trans);
item->SaveToDB(trans);
AH->SaveToDB(trans);
_player->SaveInventoryAndGoldToDB(trans);
CharacterDatabase.CommitTransaction(trans);
SendAuctionCommandResult(AH->Id, AUCTION_SELL_ITEM, ERR_AUCTION_OK);
GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
}
else // Required stack size of auction does not match to current item stack size, clone item and set correct stack size
{
Item* newItem = item->CloneItem(finalCount, _player);
if (!newItem)
{
TC_LOG_ERROR("network", "CMSG_AUCTION_SELL_ITEM: Could not create clone of item %u", item->GetEntry());
SendAuctionCommandResult(0, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
delete AH;
return;
}
if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
{
sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
GetPlayerName().c_str(), GetAccountId(), newItem->GetTemplate()->Name1.c_str(), newItem->GetEntry(), newItem->GetCount());
}
AH->Id = sObjectMgr->GenerateAuctionID();
AH->itemGUIDLow = newItem->GetGUID().GetCounter();
AH->itemEntry = newItem->GetEntry();
AH->itemCount = newItem->GetCount();
AH->owner = _player->GetGUID().GetCounter();
AH->startbid = bid;
AH->bidder = 0;
AH->bid = 0;
AH->buyout = buyout;
AH->expire_time = time(NULL) + auctionTime;
AH->deposit = deposit;
AH->etime = etime;
AH->auctionHouseEntry = auctionHouseEntry;
TC_LOG_INFO("network", "CMSG_AUCTION_SELL_ITEM: Player %s (guid %d) is selling item %s entry %u (guid %d) with count %u with initial bid %u with buyout %u and with time %u (in sec) in auctionhouse %u",
_player->GetName().c_str(), _player->GetGUID().GetCounter(), newItem->GetTemplate()->Name1.c_str(), newItem->GetEntry(), newItem->GetGUID().GetCounter(), newItem->GetCount(), bid, buyout, auctionTime, AH->GetHouseId());
sAuctionMgr->AddAItem(newItem);
auctionHouse->AddAuction(AH);
sAuctionMgr->PendingAuctionAdd(_player, AH);
for (uint32 j = 0; j < itemsCount; ++j)
{
Item* item2 = items[j];
// Item stack count equals required count, ready to delete item - cloned item will be used for auction
if (item2->GetCount() == count[j])
{
_player->MoveItemFromInventory(item2->GetBagSlot(), item2->GetSlot(), true);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
item2->DeleteFromInventoryDB(trans);
item2->DeleteFromDB(trans);
CharacterDatabase.CommitTransaction(trans);
delete item2;
}
else // Item stack count is bigger than required count, update item stack count and save to database - cloned item will be used for auction
{
item2->SetCount(item2->GetCount() - count[j]);
item2->SetState(ITEM_CHANGED, _player);
_player->ItemRemovedQuestCheck(item2->GetEntry(), count[j]);
item2->SendUpdateToPlayer(_player);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
item2->SaveToDB(trans);
CharacterDatabase.CommitTransaction(trans);
}
}
SQLTransaction trans = CharacterDatabase.BeginTransaction();
newItem->SaveToDB(trans);
AH->SaveToDB(trans);
_player->SaveInventoryAndGoldToDB(trans);
CharacterDatabase.CommitTransaction(trans);
SendAuctionCommandResult(AH->Id, AUCTION_SELL_ITEM, ERR_AUCTION_OK);
GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
}
}
void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
{
// TODO: add targets.read() check
CHECK_PACKET_SIZE(recvPacket,1+1+1+4+8+4+1);
Player* pUser = _player;
uint8 bagIndex, slot;
uint8 unk_flags; // flags (if 0x02 - some additional data are received)
uint8 cast_count; // next cast if exists (single or not)
uint64 item_guid;
uint32 glyphIndex; // something to do with glyphs?
uint32 spellid; // casted spell id
recvPacket >> bagIndex >> slot >> cast_count >> spellid >> item_guid >> glyphIndex >> unk_flags;
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if(!pItem)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
if(pItem->GetGUID() != item_guid)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
sLog.outDetail("WORLD: CMSG_USE_ITEM packet, bagIndex: %u, slot: %u, cast_count: %u, spellid: %u, Item: %u, glyphIndex: %u, unk_flags: %u, data length = %i", bagIndex, slot, cast_count, spellid, pItem->GetEntry(), glyphIndex, unk_flags, recvPacket.size());
ItemPrototype const *proto = pItem->GetProto();
if(!proto)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// some item classes can be used only in equipped state
if(proto->InventoryType != INVTYPE_NON_EQUIP && !pItem->IsEquipped())
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
uint8 msg = pUser->CanUseItem(pItem);
if( msg != EQUIP_ERR_OK )
{
pUser->SendEquipError( msg, pItem, NULL );
return;
}
// only allow conjured consumable, bandage, poisons (all should have the 2^21 item flag set in DB)
if( proto->Class == ITEM_CLASS_CONSUMABLE &&
!(proto->Flags & ITEM_FLAGS_USEABLE_IN_ARENA) &&
pUser->InArena())
{
pUser->SendEquipError(EQUIP_ERR_NOT_DURING_ARENA_MATCH,pItem,NULL);
return;
}
if (pUser->isInCombat())
{
for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
{
if (SpellEntry const *spellInfo = sSpellStore.LookupEntry(proto->Spells[i].SpellId))
{
if (IsNonCombatSpell(spellInfo))
{
pUser->SendEquipError(EQUIP_ERR_NOT_IN_COMBAT,pItem,NULL);
return;
}
}
}
}
// check also BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
if( pItem->GetProto()->Bonding == BIND_WHEN_USE || pItem->GetProto()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetProto()->Bonding == BIND_QUEST_ITEM )
{
if (!pItem->IsSoulBound())
{
pItem->SetState(ITEM_CHANGED, pUser);
pItem->SetBinding( true );
}
}
SpellCastTargets targets;
if(!targets.read(&recvPacket, pUser))
return;
//Note: If script stop casting it must send appropriate data to client to prevent stuck item in gray state.
if(!Script->ItemUse(pUser,pItem,targets))
{
// no script or script not process request by self
pUser->CastItemUseSpell(pItem,targets,cast_count,glyphIndex);
}
}
void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
{
// TODO: add targets.read() check
CHECK_PACKET_SIZE(recvPacket,1+1+1+1+8);
Player* pUser = _player;
uint8 bagIndex, slot;
uint8 spell_count; // number of spells at item, not used
uint8 cast_count; // next cast if exists (single or not)
uint64 item_guid;
recvPacket >> bagIndex >> slot >> spell_count >> cast_count >> item_guid;
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if(!pItem)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
if(pItem->GetGUID() != item_guid)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
sLog.outDetail("WORLD: CMSG_USE_ITEM packet, bagIndex: %u, slot: %u, spell_count: %u , cast_count: %u, Item: %u, data length = %i", bagIndex, slot, spell_count, cast_count, pItem->GetEntry(), recvPacket.size());
ItemPrototype const *proto = pItem->GetProto();
if(!proto)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// some item classes can be used only in equipped state
if(proto->InventoryType != INVTYPE_NON_EQUIP && !pItem->IsEquipped())
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
uint8 msg = pUser->CanUseItem(pItem);
if( msg != EQUIP_ERR_OK )
{
pUser->SendEquipError( msg, pItem, NULL );
return;
}
// only allow conjured consumable, bandage, poisons (all should have the 2^21 item flag set in DB)
if( proto->Class == ITEM_CLASS_CONSUMABLE &&
!(proto->Flags & ITEM_FLAGS_USEABLE_IN_ARENA) &&
pUser->InArena())
{
pUser->SendEquipError(EQUIP_ERR_NOT_DURING_ARENA_MATCH,pItem,NULL);
return;
}
if (pUser->isInCombat())
{
for(int i = 0; i < 5; ++i)
{
if (SpellEntry const *spellInfo = sSpellStore.LookupEntry(proto->Spells[i].SpellId))
{
if (IsNonCombatSpell(spellInfo))
{
pUser->SendEquipError(EQUIP_ERR_NOT_IN_COMBAT,pItem,NULL);
return;
}
}
}
}
// check also BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
if( pItem->GetProto()->Bonding == BIND_WHEN_USE || pItem->GetProto()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetProto()->Bonding == BIND_QUEST_ITEM )
{
if (!pItem->IsSoulBound())
{
pItem->SetState(ITEM_CHANGED, pUser);
pItem->SetBinding( true );
}
}
SpellCastTargets targets;
if(!targets.read(&recvPacket, pUser))
return;
//Note: If script stop casting it must send appropriate data to client to prevent stuck item in gray state.
if(!Script->ItemUse(pUser,pItem,targets))
{
// no script or script not process request by self
// special learning case
if(pItem->GetProto()->Spells[0].SpellId==SPELL_ID_GENERIC_LEARN)
{
uint32 learning_spell_id = pItem->GetProto()->Spells[1].SpellId;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(SPELL_ID_GENERIC_LEARN);
if(!spellInfo)
{
sLog.outError("Item (Entry: %u) in have wrong spell id %u, ignoring ",proto->ItemId, SPELL_ID_GENERIC_LEARN);
pUser->SendEquipError(EQUIP_ERR_NONE,pItem,NULL);
return;
}
Spell *spell = new Spell(pUser, spellInfo, false);
spell->m_CastItem = pItem;
spell->m_cast_count = cast_count; //set count of casts
spell->m_currentBasePoints[0] = learning_spell_id;
spell->prepare(&targets);
return;
}
// use triggered flag only for items with many spell casts and for not first cast
int count = 0;
for(int i = 0; i < 5; ++i)
{
_Spell const& spellData = pItem->GetProto()->Spells[i];
// no spell
if(!spellData.SpellId)
continue;
// wrong triggering type
if( spellData.SpellTrigger != ITEM_SPELLTRIGGER_ON_USE && spellData.SpellTrigger != ITEM_SPELLTRIGGER_ON_NO_DELAY_USE)
continue;
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellData.SpellId);
if(!spellInfo)
{
sLog.outError("Item (Entry: %u) in have wrong spell id %u, ignoring ",proto->ItemId, spellData.SpellId);
continue;
}
Spell *spell = new Spell(pUser, spellInfo, (count > 0));
spell->m_CastItem = pItem;
spell->m_cast_count = cast_count; //set count of casts
spell->prepare(&targets);
++count;
}
}
}
bool EyeOfTheStorm::GivePoints(uint32 team, uint32 points)
{
if(m_ended || !m_started)
return false;
//printf("EOTS: Give team %u %u points.\n", team, points);
m_points[team] += points;
if( m_points[team] >= m_resourceRewards[team] )
{
m_resourceRewards[team] += m_resToGainBH;
for(set<Player* >::iterator itx = m_players[team].begin(); itx != m_players[team].end(); itx++)
{
Player* plr = (*itx);
if(!plr) continue;
(*itx)->m_bgScore.BonusHonor += m_bonusHonor;
HonorHandler::AddHonorPointsToPlayer( plr, m_bonusHonor );
}
}
if( m_points[team] >= 1600 )
{
m_points[team] = 1600;
m_mapMgr->GetStateManager().UpdateWorldState( WORLDSTATE_EOTS_ALLIANCE_VICTORYPOINTS + team, m_points[team] );
m_ended = true;
m_losingteam = (team) ? 0 : 1;
m_nextPvPUpdateTime = 0;
sEventMgr.RemoveEvents(this);
sEventMgr.AddEvent(TO_CBATTLEGROUND(this), &CBattleground::Close, EVENT_BATTLEGROUND_CLOSE, 120000, 1,0);
SendChatMessage( CHAT_MSG_BG_SYSTEM_NEUTRAL, 0, "|cffffff00This battleground will close in 2 minutes.");
/* add the marks of honor to all players */
m_mainLock.Acquire();
for(uint32 i = 0; i < 2; i++)
{
for(set<Player* >::iterator itr = m_players[i].begin(); itr != m_players[i].end(); itr++)
{
(*itr)->Root();
if( (*itr)->HasFlag(PLAYER_FLAGS, PLAYER_FLAG_AFK) )
continue;
// create eye of the storm mark of honor
uint32 item_count = (i == m_losingteam) ? 1 : 3;
if( i != m_losingteam )
{
(*itr)->m_bgScore.BonusHonor += 2*m_bonusHonor;
HonorHandler::AddHonorPointsToPlayer( (*itr), 2*m_bonusHonor );
if((*itr)->fromrandombg)
{
(*itr)->m_honorToday += (*itr)->GenerateRBGReward((*itr)->getLevel(),5);
HonorHandler::RecalculateHonorFields((*itr));
(*itr)->fromrandombg = false;
}
}
else
{
(*itr)->m_bgScore.BonusHonor += m_bonusHonor;
HonorHandler::AddHonorPointsToPlayer( (*itr), m_bonusHonor );
uint32 diff = abs((int32)(m_points[i] - m_points[i ? 0 : 1]));
(*itr)->GetAchievementInterface()->HandleAchievementCriteriaWinBattleground( m_mapMgr->GetMapId(), diff, ((uint32)UNIXTIME - m_startTime) / 1000, TO_CBATTLEGROUND(this));
if((*itr)->fromrandombg)
{
Player * p = (*itr);
p->AddArenaPoints(p->randombgwinner == false ? p->GenerateRBGReward(p->getLevel(),25) : p->GenerateRBGReward(p->getLevel(),0));
p->m_honorToday += p->randombgwinner == false ? p->GenerateRBGReward(p->getLevel(),30) : p->GenerateRBGReward(p->getLevel(),15);
HonorHandler::RecalculateHonorFields(p);
p->randombgwinner = true;
p->fromrandombg = false;
}
}
Item* pReward;
SlotResult res;
if( ( pReward = (*itr)->GetItemInterface()->FindItemLessMax(EOTS_MARK_ID, item_count, false) ) == NULL )
{
res = (*itr)->GetItemInterface()->FindFreeInventorySlot( ItemPrototypeStorage.LookupEntry(EOTS_MARK_ID) );
if( !res.Result )
{
(*itr)->BroadcastMessage("Could not add EOTS mark. Make sure you have room in your inventory.");
continue;
}
pReward = objmgr.CreateItem(EOTS_MARK_ID, (*itr));
pReward->SetUInt32Value(ITEM_FIELD_STACK_COUNT, item_count);
pReward->m_isDirty = true;
if( !(*itr)->GetItemInterface()->SafeAddItem(pReward, res.ContainerSlot, res.Slot) )
{
if( !(*itr)->GetItemInterface()->AddItemToFreeSlot(pReward) )
{
pReward->DeleteMe();
pReward = NULLGOB;
}
}
(*itr)->GetSession()->SendItemPushResult(pReward,true,false,true,false,res.ContainerSlot,res.Slot, item_count);
}
else
{
pReward->m_isDirty = true;
pReward->ModUnsigned32Value(ITEM_FIELD_STACK_COUNT, item_count);
res.ContainerSlot = (*itr)->GetItemInterface()->GetBagSlotByGuid(pReward->GetGUID());
res.Slot = -1;
(*itr)->GetSession()->SendItemPushResult(pReward,true,false,true,true,res.ContainerSlot,res.Slot, item_count);
}
}
}
UpdatePvPData();
m_mainLock.Release();
return true;
}
m_mapMgr->GetStateManager().UpdateWorldState( WORLDSTATE_EOTS_ALLIANCE_VICTORYPOINTS + team, m_points[team] );
return false;
}
void LootRoll::Finalize()
{
sEventMgr.RemoveEvents(this);
// this we will have to finalize with groups types.. for now
// we'll just assume need before greed. person with highest roll
// in need gets the item.
uint32 highest = 0;
int8 hightype = -1;
uint64 player = 0;
WorldPacket data(34);
/*
Player * gplr = NULL;
for(std::map<uint64, uint32>::iterator itr = NeedRolls.begin(); itr != NeedRolls.end(); ++itr)
{
gplr = _mgr->GetPlayer((uint32)itr->first);
if(gplr) break;
}
if(!gplr)
{
for(std::map<uint64, uint32>::iterator itr = GreedRolls.begin(); itr != GreedRolls.end(); ++itr)
{
gplr = _mgr->GetPlayer((uint32)itr->first);
if(gplr) break;
}
}
*/
for(std::map<uint32, uint32>::iterator itr = m_NeedRolls.begin(); itr != m_NeedRolls.end(); ++itr)
{
if(itr->second > highest)
{
highest = itr->second;
player = itr->first;
hightype = LOOT_ROLL_TYPE_NEED;
}
/*
data.Initialize(SMSG_LOOT_ROLL);
data << _guid << _slotid << itr->first;
data << _itemid << random_suffix_factor << random_suffix_id;
data << uint8(itr->second) << uint8(LOOT_ROLL_TYPE_NEED);
if(gplr && gplr->GetGroup())
gplr->GetGroup()->SendPacketToAll(&data);
*/
}
if(!highest)
{
for(std::map<uint32, uint32>::iterator itr = m_GreedRolls.begin(); itr != m_GreedRolls.end(); ++itr)
{
if(itr->second > highest)
{
highest = itr->second;
player = itr->first;
hightype = LOOT_ROLL_TYPE_GREED;
}
/*
data.Initialize(SMSG_LOOT_ROLL);
data << _guid << _slotid << itr->first;
data << _itemid << random_suffix_factor << random_suffix_id;
data << uint8(itr->second) << uint8(LOOT_ROLL_TYPE_GREED);
if(gplr && gplr->GetGroup())
gplr->GetGroup()->SendPacketToAll(&data);
*/
}
}
Loot * pLoot = 0;
uint32 guidtype = GET_TYPE_FROM_GUID(_guid);
if( guidtype == HIGHGUID_TYPE_UNIT )
{
Creature * pc = _mgr->GetCreature( _guid );
if(pc) pLoot = &pc->loot;
}
else if( guidtype == HIGHGUID_TYPE_GAMEOBJECT )
{
GameObject * go = _mgr->GetGameObject( _guid );
if(go) pLoot = &go->loot;
}
if(!pLoot)
{
delete this;
return;
}
if(_slotid >= pLoot->items.size())
{
delete this;
return;
}
pLoot->items.at(_slotid).roll = NULL;
uint32 itemid = pLoot->items.at(_slotid).item.itemproto->ItemId;
uint32 amt = pLoot->items.at(_slotid).iItemsCount;
if(!amt)
{
delete this;
return;
}
Player * _player = (player) ? _mgr->GetPlayer( player ) : 0;
if(!player || !_player)
{
/* all passed */
data.Initialize(SMSG_LOOT_ALL_PASSED);
data << _guid << _groupcount << _itemid << random_suffix_factor << random_suffix_id;
set<uint32>::iterator pitr = m_passRolls.begin();
while(_player == NULL && pitr != m_passRolls.end())
_player = _mgr->GetPlayer( (*(pitr++)) );
if( _player != NULL )
{
if(_player->InGroup())
_player->GetGroup()->SendPacketToAll(&data);
else
_player->GetSession()->SendPacket(&data);
}
/* item can now be looted by anyone :) */
pLoot->items.at(_slotid).passed = true;
delete this;
return;
}
/*
0C BA 0E D0 0E 00 30 F1 - guid
00 00 00 00 slot
7A 16 00 00 itemid
00 26 81 8E randomfactor
00 00 00 00 randomid
07 34 42 02 00 00 00 07 -guid
0C roll
01 roll type
*/
pLoot->items.at(_slotid).roll = NULL;
data.Initialize(SMSG_LOOT_ROLL_WON);
data << _guid << _slotid << _itemid << random_suffix_factor << random_suffix_id;
data << _player->GetGUID() << uint8(highest) << uint8(hightype);
if(_player->InGroup())
_player->GetGroup()->SendPacketToAll(&data);
else
_player->GetSession()->SendPacket(&data);
ItemPrototype* it = ItemPrototypeStorage.LookupEntry(itemid);
int8 error;
if((error = _player->GetItemInterface()->CanReceiveItem(it, 1)) != 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, error);
return;
}
Item * add = _player->GetItemInterface()->FindItemLessMax(itemid, amt, false);
if (!add)
{
SlotResult slotresult = _player->GetItemInterface()->FindFreeInventorySlot(it);
if(!slotresult.Result)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, INV_ERR_INVENTORY_FULL);
return;
}
sLog.outDebug("AutoLootItem MISC");
Item *item = objmgr.CreateItem( itemid, _player);
item->SetUInt32Value(ITEM_FIELD_STACK_COUNT,amt);
if(pLoot->items.at(_slotid).iRandomProperty!=NULL)
{
item->SetRandomProperty(pLoot->items.at(_slotid).iRandomProperty->ID);
item->ApplyRandomProperties(false);
}
else if(pLoot->items.at(_slotid).iRandomSuffix != NULL)
{
item->SetRandomSuffix(pLoot->items.at(_slotid).iRandomSuffix->id);
item->ApplyRandomProperties(false);
}
AddItemResult res = _player->GetItemInterface()->SafeAddItem(item,slotresult.ContainerSlot, slotresult.Slot);
if( res == ADD_ITEM_RESULT_OK )
{
_player->GetSession()->SendItemPushResult(item,false,true,true,true,slotresult.ContainerSlot,slotresult.Slot,1);
sQuestMgr.OnPlayerItemPickup(_player,item);
}
else if( res == ADD_ITEM_RESULT_ERROR )
{
item->DeleteMe();
item = NULL;
}
}
else
{
add->SetCount(add->GetUInt32Value(ITEM_FIELD_STACK_COUNT) + amt);
add->m_isDirty = true;
sQuestMgr.OnPlayerItemPickup(_player,add);
_player->GetSession()->SendItemPushResult(add, false, true, true, false, _player->GetItemInterface()->GetBagSlotByGuid(add->GetGUID()), 0xFFFFFFFF, 1);
}
pLoot->items.at(_slotid).iItemsCount=0;
// this gets sent to all looters
data.Initialize(SMSG_LOOT_REMOVED);
data << uint8(_slotid);
Player * plr;
for(LooterSet::iterator itr = pLoot->looters.begin(); itr != pLoot->looters.end(); ++itr)
{
if((plr = _player->GetMapMgr()->GetPlayer(*itr)) != 0)
plr->GetSession()->SendPacket(&data);
}
/*WorldPacket idata(45);
_player->GetSession()->BuildItemPushResult(&idata, _player->GetGUID(), ITEM_PUSH_TYPE_LOOT, amt, itemid, pLoot->items.at(_slotid).iRandomProperty ? pLoot->items.at(_slotid).iRandomProperty->ID : 0);
if(_player->InGroup())
_player->GetGroup()->SendPacketToAll(&idata);
else
_player->GetSession()->SendPacket(&idata);*/
delete this;
}
//called when player takes item attached in mail
void WorldSession::HandleMailTakeItem(WorldPacket& recvData)
{
ObjectGuid mailbox;
uint32 mailId;
uint32 itemId;
recvData >> mailbox;
recvData >> mailId;
recvData >> itemId; // item guid low
if (!CanOpenMailBox(mailbox))
return;
Player* player = _player;
Mail* m = player->GetMail(mailId);
if (!m || m->state == MAIL_STATE_DELETED || m->deliver_time > time(nullptr))
{
player->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_INTERNAL_ERROR);
return;
}
// verify that the mail has the item to avoid cheaters taking COD items without paying
if (std::find_if(m->items.begin(), m->items.end(), [itemId](MailItemInfo info){ return info.item_guid == itemId; }) == m->items.end())
{
player->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_INTERNAL_ERROR);
return;
}
// prevent cheating with skip client money check
if (!player->HasEnoughMoney(m->COD))
{
player->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_NOT_ENOUGH_MONEY);
return;
}
Item* it = player->GetMItem(itemId);
ItemPosCountVec dest;
uint8 msg = _player->CanStoreItem(NULL_BAG, NULL_SLOT, dest, it, false);
if (msg == EQUIP_ERR_OK)
{
SQLTransaction trans = CharacterDatabase.BeginTransaction();
m->RemoveItem(itemId);
m->removedItems.push_back(itemId);
if (m->COD > 0) //if there is COD, take COD money from player and send them to sender by mail
{
ObjectGuid sender_guid(HighGuid::Player, m->sender);
Player* receiver = ObjectAccessor::FindConnectedPlayer(sender_guid);
uint32 sender_accId = 0;
if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
{
std::string sender_name;
if (receiver)
{
sender_accId = receiver->GetSession()->GetAccountId();
sender_name = receiver->GetName();
}
else
{
// can be calculated early
sender_accId = sCharacterCache->GetCharacterAccountIdByGuid(sender_guid);
if (!sCharacterCache->GetCharacterNameByGuid(sender_guid, sender_name))
sender_name = sObjectMgr->GetTrinityStringForDBCLocale(LANG_UNKNOWN);
}
sLog->outCommand(GetAccountId(), "GM %s (Account: %u) receiver mail item: %s (Entry: %u Count: %u) and send COD money: %u to player: %s (Account: %u)",
GetPlayerName().c_str(), GetAccountId(), it->GetTemplate()->Name1.c_str(), it->GetEntry(), it->GetCount(), m->COD, sender_name.c_str(), sender_accId);
}
else if (!receiver)
sender_accId = sCharacterCache->GetCharacterAccountIdByGuid(sender_guid);
// check player existence
if (receiver || sender_accId)
{
MailDraft(m->subject, "")
.AddMoney(m->COD)
.SendMailTo(trans, MailReceiver(receiver, m->sender), MailSender(MAIL_NORMAL, m->receiver), MAIL_CHECK_MASK_COD_PAYMENT);
}
player->ModifyMoney(-int32(m->COD));
}
m->COD = 0;
m->state = MAIL_STATE_CHANGED;
player->m_mailsUpdated = true;
player->RemoveMItem(it->GetGUID().GetCounter());
uint32 count = it->GetCount(); // save counts before store and possible merge with deleting
it->SetState(ITEM_UNCHANGED); // need to set this state, otherwise item cannot be removed later, if neccessary
player->MoveItemToInventory(dest, it, true);
player->SaveInventoryAndGoldToDB(trans);
player->_SaveMail(trans);
CharacterDatabase.CommitTransaction(trans);
player->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_OK, 0, itemId, count);
}
else
player->SendMailResult(mailId, MAIL_ITEM_TAKEN, MAIL_ERR_EQUIP_ERROR, msg);
}
uint CGSaveEquipSuitHandler::Execute(CGSaveEquipSuit* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer ;
Assert( pGamePlayer ) ;
Obj_Human* pHuman = pGamePlayer->GetHuman() ;
Assert( pHuman ) ;
Scene* pScene = pHuman->getScene() ;
if( pScene==NULL )
{
Assert(FALSE) ;
return PACKET_EXE_ERROR ;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID ) ;
UINT nSuitNum = pPacket->getSuitNum();
if(nSuitNum>MAX_EQUIP_SUIT_NUM)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: nSuitNum=%d", nSuitNum ) ;
return PACKET_EXE_ERROR ;
}
ItemContainer* pItemContainer = pHuman->GetEquipContain();
Assert(pItemContainer);
BOOL bDataValid = TRUE;
BYTE nResult = EQUIPSUIT_EQUIP_FAIL;
GCSaveEquipSuitResult Msg;
_SUIT_SETTING suitSetting = pPacket->getSuitSetting();
for(INT i=0; i<HEQUIP_NUMBER; ++i)
{
//有数据
if(!suitSetting.m_EquipData[i].isNull())
{
Item* pEquip = pItemContainer->GetItem(i);
Assert(pEquip);
//装备点有数据
if(!pEquip->IsEmpty())
{
if(!(pEquip->GetGUID() == suitSetting.m_EquipData[i]))
{
//检查背包里有没有
UINT nPos = HumanItemLogic::GetBagItemPosByGUID(pHuman, suitSetting.m_EquipData[i]);
//找不到
if(nPos == INVALID_INDEX)
{
bDataValid = FALSE;
break;
}
//从背包里找到
Item* pUseItem = HumanItemLogic::GetBagItem(pHuman ,nPos);
//判断类型
if(pUseItem->GetItemClass() != ICLASS_EQUIP)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: Equip is not ICLASS_EQUIP, EquipPoint=%d", i ) ;
return PACKET_EXE_ERROR ;
}
//判断装备点
if(pUseItem->GetEquipPoint() != i)
{
if(pUseItem->GetEquipPoint() == HEQUIP_RING1)
{
if((i != HEQUIP_RING1)&&(i != HEQUIP_RING2))
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EquipPoint error , pUseItem->GetEquipPoint()=%d", pUseItem->GetEquipPoint() ) ;
return PACKET_EXE_ERROR ;
}
}
else if(pUseItem->GetEquipPoint() == HEQUIP_ADORN1)
{
if((i != HEQUIP_ADORN1)&&(i != HEQUIP_ADORN2))
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EquipPoint error , pUseItem->GetEquipPoint()=%d", pUseItem->GetEquipPoint() ) ;
return PACKET_EXE_ERROR ;
}
}
else
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EquipPoint error , pUseItem->GetEquipPoint()=%d", pUseItem->GetEquipPoint() ) ;
return PACKET_EXE_ERROR ;
}
}
//判断等级
if(pUseItem->GetRequireLevel() > pHuman->GetLevel() )
{
nResult = EQUIPSUIT_LEVEL;
Msg.setResult(nResult);
Msg.setSuitNum(0);
pGamePlayer->SendPacket(&Msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: Equiplevel , pUseItem->GetRequireLevel()=%d", pUseItem->GetRequireLevel() ) ;
return PACKET_EXE_CONTINUE;
}
//判断职业
if(!pUseItem->IsWuMenPai())
{
if(!pUseItem->InReqJob(pHuman->GetMenPai()))
{
nResult = EQUIPSUIT_JOB_FAIL;
Msg.setResult(nResult);
Msg.setSuitNum(0);
pGamePlayer->SendPacket(&Msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: ReqJob , pUseItem->GetReqJob ") ;
return PACKET_EXE_CONTINUE;
}
}
//来自背包正常数据,继续下一个查询
continue;
}
}
//装备点没有数据，要检查背包
else
{
//检查背包里有没有
UINT nPos = HumanItemLogic::GetBagItemPosByGUID(pHuman, suitSetting.m_EquipData[i]);
//找不到
if(nPos == INVALID_INDEX)
{
bDataValid = FALSE;
break;
}
//从背包里找到
Item* pUseItem = HumanItemLogic::GetBagItem(pHuman ,nPos);
//判断类型
if(pUseItem->GetItemClass() != ICLASS_EQUIP)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: Equip is not ICLASS_EQUIP, EquipPoint=%d", i ) ;
return PACKET_EXE_ERROR ;
}
//判断装备点
if(pUseItem->GetEquipPoint() != i)
{
if(pUseItem->GetEquipPoint() == HEQUIP_RING1)
{
if((i != HEQUIP_RING1)&&(i != HEQUIP_RING2))
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EquipPoint error , pUseItem->GetEquipPoint()=%d", pUseItem->GetEquipPoint() ) ;
return PACKET_EXE_ERROR ;
}
}
else if(pUseItem->GetEquipPoint() == HEQUIP_ADORN1)
{
if((i != HEQUIP_ADORN1)&&(i != HEQUIP_ADORN2))
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EquipPoint error , pUseItem->GetEquipPoint()=%d", pUseItem->GetEquipPoint() ) ;
return PACKET_EXE_ERROR ;
}
}
else
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EquipPoint error , pUseItem->GetEquipPoint()=%d", pUseItem->GetEquipPoint() ) ;
return PACKET_EXE_ERROR ;
}
}
//判断等级
if(pUseItem->GetRequireLevel() > pHuman->GetLevel() )
{
nResult = EQUIPSUIT_LEVEL;
Msg.setResult(nResult);
Msg.setSuitNum(0);
pGamePlayer->SendPacket(&Msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: Equiplevel , pUseItem->GetRequireLevel()=%d", pUseItem->GetRequireLevel() ) ;
return PACKET_EXE_CONTINUE;
}
//判断职业
if(!pUseItem->IsWuMenPai())
{
if(!pUseItem->InReqJob(pHuman->GetMenPai()))
{
nResult = EQUIPSUIT_JOB_FAIL;
Msg.setResult(nResult);
Msg.setSuitNum(0);
pGamePlayer->SendPacket(&Msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: ReqJob ") ;
return PACKET_EXE_CONTINUE;
}
}
}
}
}
//存在无效数据
if(bDataValid == FALSE)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: EQUIP don't exsist " ) ;
return PACKET_EXE_CONTINUE; ;
}
//保存
pHuman->SetEquipSuitSetting(suitSetting, nSuitNum);
nResult = EQUIPSUIT_SUCCESS;
Msg.setResult(nResult);
Msg.setSuitNum(nSuitNum);
Msg.setSuitSetting(pHuman->GetEquipSuitSetting(nSuitNum));
pGamePlayer->SendPacket(&Msg);
g_pLog->FastSaveLog( LOG_FILE_1, "CGSaveEquipSuitHandler: nSuitNum=%d", nSuitNum ) ;
return PACKET_EXE_CONTINUE ;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
{
uint8 bagIndex, slot;
uint8 spell_count; // number of spells at item, not used
uint8 cast_count; // next cast if exists (single or not)
uint64 item_guid;
recvPacket >> bagIndex >> slot >> spell_count >> cast_count >> item_guid;
// TODO: add targets.read() check
Player* pUser = _player;
// ignore for remote control state
if (!pUser->IsSelfMover())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
return;
}
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if(!pItem)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
if(pItem->GetGUID() != item_guid)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
DETAIL_LOG("WORLD: CMSG_USE_ITEM packet, bagIndex: %u, slot: %u, spell_count: %u , cast_count: %u, Item: %u, data length = %i", bagIndex, slot, spell_count, cast_count, pItem->GetEntry(), (uint32)recvPacket.size());
ItemPrototype const *proto = pItem->GetProto();
if(!proto)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// some item classes can be used only in equipped state
if(proto->InventoryType != INVTYPE_NON_EQUIP && !pItem->IsEquipped())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
uint8 msg = pUser->CanUseItem(pItem);
if( msg != EQUIP_ERR_OK )
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError( msg, pItem, NULL );
return;
}
// not allow use item from trade (cheat way only)
if (pItem->IsInTrade())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// only allow conjured consumable, bandage, poisons (all should have the 2^21 item flag set in DB)
if (proto->Class == ITEM_CLASS_CONSUMABLE &&
!(proto->Flags & ITEM_FLAG_USEABLE_IN_ARENA) &&
pUser->InArena())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_NOT_DURING_ARENA_MATCH,pItem,NULL);
return;
}
if (pUser->isInCombat())
{
for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
{
if (SpellEntry const *spellInfo = sSpellStore.LookupEntry(proto->Spells[i].SpellId))
{
if (IsNonCombatSpell(spellInfo))
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_NOT_IN_COMBAT,pItem,NULL);
return;
}
}
}
}
// check also BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
if( pItem->GetProto()->Bonding == BIND_WHEN_USE || pItem->GetProto()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetProto()->Bonding == BIND_QUEST_ITEM )
{
if (!pItem->IsSoulBound())
{
pItem->SetState(ITEM_CHANGED, pUser);
pItem->SetBinding( true );
}
}
SpellCastTargets targets;
recvPacket >> targets.ReadForCaster(pUser);
targets.Update(pUser);
if (!pItem->IsTargetValidForItemUse(targets.getUnitTarget()))
{
// free gray item after use fail
pUser->SendEquipError(EQUIP_ERR_NONE, pItem, NULL);
// search spell for spell error
uint32 spellid = 0;
for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
{
if( proto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_USE || proto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE)
{
spellid = proto->Spells[i].SpellId;
break;
}
}
// send spell error
if (SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid))
Spell::SendCastResult(_player,spellInfo,cast_count,SPELL_FAILED_BAD_TARGETS);
return;
}
//Note: If script stop casting it must send appropriate data to client to prevent stuck item in gray state.
if (!sScriptMgr.OnItemUse(pUser, pItem, targets))
{
// no script or script not process request by self
pUser->CastItemUseSpell(pItem,targets,cast_count);
}
}
uint CGEquipRemouldHandler::Execute(CGEquipRemould* pPacket,Player* pPlayer)
{
__ENTER_FUNCTION
GamePlayer* pGamePlayer = (GamePlayer*)pPlayer;
Assert( pGamePlayer );
Obj_Human* pHuman = pGamePlayer->GetHuman();
Assert( pHuman );
Scene* pScene = pHuman->getScene();
if( pScene==NULL )
{
Assert(FALSE);
return PACKET_EXE_ERROR;
}
//检查线程执行资源是否正确
Assert( MyGetCurrentThreadID()==pScene->m_ThreadID );
//交易状态不可操作
if(pHuman->m_ExchangBox.m_Status > 0)
{//丢弃
g_pLog->FastSaveLog( LOG_FILE_1, "ERROR: ObjID=%d, ExchangBox::m_Status>0" ,pHuman->GetID()) ;
return PACKET_EXE_CONTINUE ;
}
//摆摊状态不可操作
if(pHuman->m_StallBox.GetStallStatus() == ServerStallBox::STALL_OPEN)
{//丢弃
g_pLog->FastSaveLog( LOG_FILE_1, "ERROR: ObjID=%d, ServerStallBox::STALL_OPEN" ,pHuman->GetID()) ;
return PACKET_EXE_CONTINUE ;
}
Item* pEquipItem = NULL;
UINT EquipPoint = INVALID_ITEM_POS;
UINT BagIndex = INVALID_ITEM_POS;
EQUIPREMOULD_RESULT nResult = EQUIPREMOULD_FAIL;
GCEquipRemouldResult Msg;
switch(pPacket->GetEquipPosType())
{
case ENUM_EQUIP_POINT:
{
EquipPoint = pPacket->GetPos();
if(EquipPoint>HEQUIP_ADORN2)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler: EquipPoint error, EquipPoint=%d", EquipPoint) ;
return PACKET_EXE_ERROR;
}
ItemContainer* pEquipContainer = pHuman->GetEquipContain();
if(NULL==pEquipContainer)
{
AssertEx(FALSE,"[CGEquipRemouldHandler]: NULL EquipContainer pointer found!");
}
pEquipItem = pEquipContainer->GetItem((UINT)EquipPoint);
Assert(pEquipItem);
if(pEquipItem->IsEmpty())
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler pEquipItem is Null at EquipPoint= %d", EquipPoint) ;
return PACKET_EXE_CONTINUE;
}
Assert (pEquipItem->GetItemClass() == ICLASS_EQUIP);
if(!(pPacket->getItemID() == pEquipItem->GetGUID()))
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler GUID is different ") ;
return PACKET_EXE_CONTINUE;
}
}
break;
case ENUM_BAG:
{
BagIndex = pPacket->GetPos();
ItemContainer* pItemContainer = HumanItemLogic::GetBagContainer(pHuman,BagIndex);
if( pItemContainer == NULL )
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler: BagIndex error, BagIndex=%d", BagIndex) ;
return PACKET_EXE_ERROR;
}
if (!pItemContainer->IsCanUse())
{
nResult = EQUIPREMOULD_BAG_INVALID;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler: ItemContainer is invalid, ContainerType=%d, BagIndex=%d",
pItemContainer->GetContainerType(), BagIndex) ;
return PACKET_EXE_ERROR;
}
pEquipItem = pItemContainer->GetItem(pItemContainer->BagIndex2ConIndex(BagIndex));
if(pEquipItem->IsEmpty())
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler pEquipItem is Null at BagIndex= %d", BagIndex) ;
return PACKET_EXE_CONTINUE;
}
if (pEquipItem->GetItemClass() != ICLASS_EQUIP)
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler GetItemClass is not ICLASS_EQUIP ") ;
return PACKET_EXE_CONTINUE;
}
if(!(pPacket->getItemID() == pEquipItem->GetGUID()))
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler GUID is different ") ;
return PACKET_EXE_CONTINUE;
}
if (pEquipItem->GetItemType() > EQUIP_ADORN)
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler GUID is different ") ;
return PACKET_EXE_CONTINUE;
}
}
break;
default:
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler: EquipFromType error, EquipFromType=%d", pPacket->GetEquipPosType()) ;
return PACKET_EXE_ERROR;
}
break;
}
if (pEquipItem->GetEquipFromType() != ITEM_CREATE)
{
nResult = EQUIPREMOULD_TYPE_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler Type error ") ;
return PACKET_EXE_CONTINUE;
}
ITEM_PRODUCT_INFO_TB* pCreateTB = g_ItemTable.GetItemProductInfoTB(pEquipItem->GetItemTableIndex());
if(pCreateTB == NULL)
{
nResult = EQUIPREMOULD_EQUIP_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket(&Msg);
return PACKET_EXE_CONTINUE;
}
if (pCreateTB->m_nRemouldInfoCount != pPacket->GetValidNum())
{
return PACKET_EXE_ERROR;
}
if (pCreateTB->m_RemouldMoney > pHuman->GetMoney())
{
nResult = EQUIPREMOULD_MONEY_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket(&Msg);
return PACKET_EXE_CONTINUE;
}
struct MATERIAL_REQ
{
UINT m_nIndex;
UINT m_nCount;
};
MATERIAL_REQ MaterialIndex[MAX_REMOULD_MATERIAL_NUM];
UINT nEquipScore = 0;
for (UINT i=0; i<pCreateTB->m_nRemouldInfoCount; ++i)
{
REMOULDITEM_INFO RemouldInfo = pCreateTB->m_RemouldInfo[i];
EQUIPREMOULD_MATERIAL_INFO MaterialInfo = pPacket->GetMaterialReq(i);
if(MaterialInfo.m_nMaterialType != RemouldInfo.m_MaterialType)
{
nResult = EQUIPREMOULD_MATERIAL_FAIL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler MaterialType error") ;
return PACKET_EXE_CONTINUE;
}
if(MaterialInfo.m_nMaterialLevel < RemouldInfo.m_NeedLevel)
{
nResult = EQUIPREMOULD_MATERIAL_LEVEL;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler MaterialLevel fail") ;
return PACKET_EXE_CONTINUE;
}
UINT nMaterialIndex = GenMaterialIndex(MaterialInfo.m_nMaterialType, MaterialInfo.m_nMaterialLevel);
//查询物品表该材料是否存在
COMMITEM_INFO_TB* pMaterialInfoTB = g_ItemTable.GetCommItemInfoTB(nMaterialIndex);
if(pMaterialInfoTB == NULL)
{
return PACKET_EXE_ERROR;
}
INT nCount = HumanItemLogic::CalcBagItemCount(pHuman, nMaterialIndex);
if (nCount<RemouldInfo.m_MaterialNum)
{
nResult = EQUIPREMOULD_MATERIAL_COUNT;
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler Material num fail") ;
return PACKET_EXE_CONTINUE;
}
//获取对应材料分
MATERIAL_LEVEL_INFO_TB* pMaterialLevelInfo = g_ItemTable.GetMaterialInfoTB(MaterialInfo.m_nMaterialLevel);
Assert(pMaterialLevelInfo != NULL);
if (!pMaterialLevelInfo)
{
g_pLog->FastSaveLog( LOG_FILE_1, "[CGEquipRemouldHandler::Execute] GetMaterialInfoTB index is error [%d]",MaterialInfo.m_nMaterialLevel);
return PACKET_EXE_ERROR;
}
nEquipScore = nEquipScore + pMaterialLevelInfo->m_MaterialValue;
MaterialIndex[i].m_nIndex = nMaterialIndex;
MaterialIndex[i].m_nCount = pCreateTB->m_RemouldInfo[i].m_MaterialNum;
}
nResult = (EQUIPREMOULD_RESULT)pHuman->EquipRemould(pEquipItem, nEquipScore);
if(nResult == EQUIPREMOULD_FAIL)
{
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler: pHuman->AddHole Fail") ;
return PACKET_EXE_ERROR;
}
if (nResult == EQUIPREMOULD_SUCCESS)
{
ITEM_LOG_PARAM LogParam;
LogParam.OpType = ITEM_REMOULD_CONSUME;
LogParam.CharGUID = pHuman->GetGUID();
LogParam.XPos = pHuman->getWorldPos()->m_fX;
LogParam.ZPos = pHuman->getWorldPos()->m_fZ;
LogParam.SceneID = pHuman->getScene()->SceneID();
for (UINT i=0; i<pCreateTB->m_nRemouldInfoCount; ++i)
{
if(HumanItemLogic::EraseBagItem(&LogParam, pHuman,MaterialIndex[i].m_nIndex, MaterialIndex[i].m_nCount))
{
SaveItemLog(&LogParam);
}
}
pHuman->SetMoney(pHuman->GetMoney() - pCreateTB->m_RemouldMoney);
MONEY_LOG_PARAM MoneyLogParam;
MoneyLogParam.CharGUID = pHuman->GetGUID();
MoneyLogParam.OPType = MONEY_REMOULD_REDUCE;
MoneyLogParam.Count = (INT)pCreateTB->m_RemouldMoney;
MoneyLogParam.SceneID = pHuman->getScene()->SceneID();
MoneyLogParam.XPos = pHuman->getWorldPos()->m_fX;
MoneyLogParam.ZPos = pHuman->getWorldPos()->m_fZ;
SaveMoneyLog(&MoneyLogParam);
}
Msg.SetResult(nResult);
pGamePlayer->SendPacket( &Msg ) ;
//////////////////////////////////////////////////////////////////////////
if((nResult == EQUIPREMOULD_SUCCESS)||(nResult == EQUIPREMOULD_MAX_FAIL))
{
if(pPacket->GetEquipPosType() == ENUM_EQUIP_POINT)
{
pHuman->ItemEffectFlush();
pHuman->SetEquipVer(pHuman->GetEquipVer()+1);
INT Equip_Point = pPacket->GetPos();
UINT RetPart = 0;
GCDetailEquipList SelfMsg;
SelfMsg.setObjID( pHuman->GetID() );
Item* pEquipItem = HumanItemLogic::GetEquip(pHuman, (HUMAN_EQUIP)Equip_Point);
if(!pEquipItem)
{
Assert(FALSE);
}
if(pEquipItem->IsEmpty())
{
Assert(FALSE);
}
pEquipItem->SaveValueTo(SelfMsg.GetEquipData((HUMAN_EQUIP)Equip_Point));
RetPart|=(1<<((UINT)Equip_Point));
SelfMsg.SetAskPart(RetPart);
pGamePlayer->SendPacket( &SelfMsg ) ;
}
else
{
GCItemInfo ItemMsg;
ItemMsg.setIsNull(FALSE);
ItemMsg.setID(BagIndex);
pEquipItem->SaveValueTo(ItemMsg.getItem());
pHuman->GetPlayer()->SendPacket(&ItemMsg);
}
}
g_pLog->FastSaveLog( LOG_FILE_1, "CGEquipRemouldHandler: success nResult=%d", nResult ) ;
return PACKET_EXE_CONTINUE;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR;
}
void WorldSession::HandleSwapInvItemOpcode( WorldPacket & recv_data )
{
if(!_player->IsInWorld()) return;
CHECK_PACKET_SIZE(recv_data, 2);
WorldPacket data;
int8 srcslot=0, dstslot=0;
int8 error=0;
recv_data >> srcslot >> dstslot;
if(!GetPlayer())
return;
sLog.outDetail("ITEM: swap, src slot: %u dst slot: %u", (uint32)srcslot, (uint32)dstslot);
if(dstslot == srcslot) // player trying to add item to the same slot
{
GetPlayer()->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, INV_ERR_ITEMS_CANT_BE_SWAPPED);
return;
}
Item * dstitem = _player->GetItemInterface()->GetInventoryItem(dstslot);
Item * srcitem = _player->GetItemInterface()->GetInventoryItem(srcslot);
// allow weapon switching in combat
bool skip_combat = false;
if( srcslot < EQUIPMENT_SLOT_END || dstslot < EQUIPMENT_SLOT_END ) // We're doing an equip swap.
{
if(_player->isInCombat())
{
if( srcslot < EQUIPMENT_SLOT_MAINHAND || dstslot < EQUIPMENT_SLOT_MAINHAND ) // These can't be swapped
{
_player->GetItemInterface()->BuildInventoryChangeError(srcitem, dstitem, INV_ERR_CANT_DO_IN_COMBAT);
return;
}
skip_combat= true;
}
}
if (!srcitem)
{
_player->GetItemInterface()->BuildInventoryChangeError(srcitem,dstitem,INV_ERR_YOU_CAN_NEVER_USE_THAT_ITEM);
return;
}
if (srcslot == dstslot)
{
_player->GetItemInterface()->BuildInventoryChangeError(srcitem,dstitem, INV_ERR_ITEM_DOESNT_GO_TO_SLOT);
return;
}
if((error=_player->GetItemInterface()->CanEquipItemInSlot(INVENTORY_SLOT_NOT_SET, dstslot, srcitem->GetProto(), skip_combat)))
{
if(dstslot < INVENTORY_KEYRING_END)
{
_player->GetItemInterface()->BuildInventoryChangeError(srcitem,dstitem, error);
return;
}
}
if(dstitem)
{
if((error=_player->GetItemInterface()->CanEquipItemInSlot(INVENTORY_SLOT_NOT_SET, srcslot, dstitem->GetProto(), skip_combat)))
{
if(srcslot < INVENTORY_KEYRING_END)
{
data.Initialize( SMSG_INVENTORY_CHANGE_FAILURE );
data << error;
if(error == 1)
{
data << dstitem->GetProto()->RequiredLevel;
}
data << (srcitem ? srcitem->GetGUID() : uint64(0));
data << (dstitem ? dstitem->GetGUID() : uint64(0));
data << uint8(0);
SendPacket( &data );
return;
}
}
}
if(srcitem->IsContainer())
{
//source has items and dst is a backpack or bank
if(((Container*)srcitem)->HasItems())
if(!_player->GetItemInterface()->IsBagSlot(dstslot))
{
_player->GetItemInterface()->BuildInventoryChangeError(srcitem,dstitem, INV_ERR_NONEMPTY_BAG_OVER_OTHER_BAG);
return;
}
if(dstitem)
{
//source is a bag and dst slot is a bag inventory and has items
if(dstitem->IsContainer())
{
if(((Container*)dstitem)->HasItems() && !_player->GetItemInterface()->IsBagSlot(srcslot))
{
_player->GetItemInterface()->BuildInventoryChangeError(srcitem,dstitem, INV_ERR_NONEMPTY_BAG_OVER_OTHER_BAG);
return;
}
}
else
{
//dst item is not a bag, swap impossible
_player->GetItemInterface()->BuildInventoryChangeError(srcitem,dstitem,INV_ERR_NONEMPTY_BAG_OVER_OTHER_BAG);
return;
}
}
//dst is bag inventory
if(dstslot < INVENTORY_SLOT_BAG_END)
{
if(srcitem->GetProto()->Bonding==ITEM_BIND_ON_EQUIP)
srcitem->SoulBind();
}
}
// swap items
_player->GetItemInterface()->SwapItemSlots(srcslot, dstslot);
}
/*Loot type MUST be
1-corpse, go
2-skinning/herbalism/minning
3-Fishing
*/
void Player::SendLoot(uint64 guid, uint8 loot_type, uint32 mapid)
{
Group* m_Group = m_playerInfo->m_Group;
if(!IsInWorld())
return;
Loot* pLoot = NULL;
uint32 guidtype = GET_TYPE_FROM_GUID(guid);
int8 loot_method;
if(m_Group != NULL)
loot_method = m_Group->GetMethod();
else
loot_method = PARTY_LOOT_FFA;
if(guidtype == HIGHGUID_TYPE_UNIT)
{
Creature* pCreature = GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!pCreature)return;
pLoot = &pCreature->loot;
m_currentLoot = pCreature->GetGUID();
}
else if(guidtype == HIGHGUID_TYPE_GAMEOBJECT)
{
GameObject* pGO = GetMapMgr()->GetGameObject(GET_LOWGUID_PART(guid));
if(!pGO)return;
pGO->SetByte(GAMEOBJECT_BYTES_1, 0, 0);
pLoot = &pGO->loot;
m_currentLoot = pGO->GetGUID();
}
else if((guidtype == HIGHGUID_TYPE_PLAYER))
{
Player* p = GetMapMgr()->GetPlayer((uint32)guid);
if(!p)return;
pLoot = &p->loot;
m_currentLoot = p->GetGUID();
}
else if((guidtype == HIGHGUID_TYPE_CORPSE))
{
Corpse* pCorpse = objmgr.GetCorpse((uint32)guid);
if(!pCorpse)return;
pLoot = &pCorpse->loot;
m_currentLoot = pCorpse->GetGUID();
}
else if((guidtype == HIGHGUID_TYPE_ITEM))
{
Item* pItem = GetItemInterface()->GetItemByGUID(guid);
if(!pItem)
return;
pLoot = pItem->loot;
m_currentLoot = pItem->GetGUID();
}
if(!pLoot)
{
// something whack happened.. damn cheaters..
return;
}
// add to looter set
pLoot->looters.insert(GetLowGUID());
WorldPacket data, data2(32);
data.SetOpcode(SMSG_LOOT_RESPONSE);
m_lootGuid = guid;
data << uint64(guid);
data << uint8(loot_type); //loot_type;
data << uint32(pLoot->gold);
data << uint8(0); //loot size reserve
std::vector<__LootItem>::iterator iter = pLoot->items.begin();
uint32 count = 0;
uint8 slottype = 0;
for(uint32 x = 0; iter != pLoot->items.end(); iter++, x++)
{
if(iter->iItemsCount == 0)
continue;
LooterSet::iterator itr = iter->has_looted.find(GetLowGUID());
if(iter->has_looted.end() != itr)
continue;
ItemPrototype* itemProto = iter->item.itemproto;
if(!itemProto)
continue;
// check if it's on ML if so only quest items and ffa loot should be shown based on mob
if(loot_method == PARTY_LOOT_MASTER && m_Group && m_Group->GetLooter() != m_playerInfo)
// pass on all ffa_loot and the grey / white items
if(!iter->ffa_loot && !(itemProto->Quality < m_Group->GetThreshold()))
continue;
// team check
if( itemProto->HasFlag2(ITEM_FLAG2_HORDE_ONLY) && IsTeamAlliance() )
continue;
if( itemProto->HasFlag2(ITEM_FLAG2_ALLIANCE_ONLY) && IsTeamHorde() )
continue;
//quest items check. type 4/5
//quest items that don't start quests.
if((itemProto->Bonding == ITEM_BIND_QUEST) && !(itemProto->QuestId) && !HasQuestForItem(itemProto->ItemId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST2) && !(itemProto->QuestId) && !HasQuestForItem(itemProto->ItemId))
continue;
//quest items that start quests need special check to avoid drops all the time.
if((itemProto->Bonding == ITEM_BIND_QUEST) && (itemProto->QuestId) && GetQuestLogForEntry(itemProto->QuestId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST2) && (itemProto->QuestId) && GetQuestLogForEntry(itemProto->QuestId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST) && (itemProto->QuestId) && HasFinishedQuest(itemProto->QuestId))
continue;
if((itemProto->Bonding == ITEM_BIND_QUEST2) && (itemProto->QuestId) && HasFinishedQuest(itemProto->QuestId))
continue;
//check for starting item quests that need questlines.
if((itemProto->QuestId && itemProto->Bonding != ITEM_BIND_QUEST && itemProto->Bonding != ITEM_BIND_QUEST2))
{
Quest* pQuest = QuestStorage.LookupEntry(itemProto->QuestId);
if(pQuest)
{
uint32 finishedCount = 0;
//check if its a questline.
for(uint32 i = 0; i < pQuest->count_requiredquests; i++)
{
if(pQuest->required_quests[i])
{
if(!HasFinishedQuest(pQuest->required_quests[i]) || GetQuestLogForEntry(pQuest->required_quests[i]))
{
}
else
{
finishedCount++;
}
}
}
}
}
slottype = 0;
if(m_Group != NULL && loot_type < 2)
{
switch(loot_method)
{
case PARTY_LOOT_MASTER:
slottype = 2;
break;
case PARTY_LOOT_GROUP:
case PARTY_LOOT_RR:
case PARTY_LOOT_NBG:
slottype = 1;
break;
default:
slottype = 0;
break;
}
// only quality items are distributed
if(itemProto->Quality < m_Group->GetThreshold())
{
slottype = 0;
}
// if all people passed anyone can loot it? :P
if(iter->passed)
slottype = 0; // All players passed on the loot
//if it is ffa loot and not an masterlooter
if(iter->ffa_loot)
slottype = 0;
}
data << uint8(x);
data << uint32(itemProto->ItemId);
data << uint32(iter->iItemsCount); //nr of items of this type
data << uint32(iter->item.displayid);
if(iter->iRandomSuffix)
{
data << uint32(Item::GenerateRandomSuffixFactor(itemProto));
data << uint32(-int32(iter->iRandomSuffix->id));
}
else if(iter->iRandomProperty)
{
data << uint32(0);
data << uint32(iter->iRandomProperty->ID);
}
else
{
data << uint32(0);
data << uint32(0);
}
data << slottype; // "still being rolled for" flag
if(slottype == 1)
{
if(iter->roll == NULL && !iter->passed)
{
int32 ipid = 0;
uint32 factor = 0;
if(iter->iRandomProperty)
ipid = iter->iRandomProperty->ID;
else if(iter->iRandomSuffix)
{
ipid = -int32(iter->iRandomSuffix->id);
factor = Item::GenerateRandomSuffixFactor(iter->item.itemproto);
}
if(iter->item.itemproto)
{
iter->roll = new LootRoll(60000, (m_Group != NULL ? m_Group->MemberCount() : 1), guid, x, itemProto->ItemId, factor, uint32(ipid), GetMapMgr());
data2.Initialize(SMSG_LOOT_START_ROLL);
data2 << guid;
data2 << uint32(mapid);
data2 << uint32(x);
data2 << uint32(itemProto->ItemId);
data2 << uint32(factor);
if(iter->iRandomProperty)
data2 << uint32(iter->iRandomProperty->ID);
else if(iter->iRandomSuffix)
data2 << uint32(ipid);
else
data2 << uint32(0);
data2 << uint32(iter->iItemsCount);
data2 << uint32(60000); // countdown
data2 << uint8(7); // some sort of flags that require research
}
Group* pGroup = m_playerInfo->m_Group;
if(pGroup)
{
pGroup->Lock();
for(uint32 i = 0; i < pGroup->GetSubGroupCount(); ++i)
{
for(GroupMembersSet::iterator itr2 = pGroup->GetSubGroup(i)->GetGroupMembersBegin(); itr2 != pGroup->GetSubGroup(i)->GetGroupMembersEnd(); ++itr2)
{
PlayerInfo* pinfo = *itr2;
if(pinfo->m_loggedInPlayer && pinfo->m_loggedInPlayer->GetItemInterface()->CanReceiveItem(itemProto, iter->iItemsCount) == 0)
{
if(pinfo->m_loggedInPlayer->m_passOnLoot)
iter->roll->PlayerRolled(pinfo->m_loggedInPlayer, 3); // passed
else
pinfo->m_loggedInPlayer->SendPacket(&data2);
}
}
}
pGroup->Unlock();
}
else
{
m_session->SendPacket(&data2);
}
}
}
count++;
}
data.wpos(13);
data << uint8(count);
m_session->SendPacket(&data);
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_LOOTING);
}
void WorldSession::HandlePetitionBuyOpcode(WorldPacket& recvData)
{
TC_LOG_DEBUG("network", "Received opcode CMSG_PETITION_BUY");
ObjectGuid guidNPC;
uint32 clientIndex; // 1 for guild and arenaslot+1 for arenas in client
std::string name;
recvData >> guidNPC; // NPC GUID
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint64>(); // 0
recvData >> name; // name
recvData.read_skip<std::string>(); // some string
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint16>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
recvData.read_skip<uint32>(); // 0
for (int i = 0; i < 10; ++i)
recvData.read_skip<std::string>();
recvData >> clientIndex; // index
recvData.read_skip<uint32>(); // 0
TC_LOG_DEBUG("network", "Petitioner %s tried sell petition: name %s", guidNPC.ToString().c_str(), name.c_str());
// prevent cheating
Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(guidNPC, UNIT_NPC_FLAG_PETITIONER);
if (!creature)
{
TC_LOG_DEBUG("network", "WORLD: HandlePetitionBuyOpcode - %s not found or you can't interact with him.", guidNPC.ToString().c_str());
return;
}
// remove fake death
if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
uint32 charterid = 0;
uint32 cost = 0;
uint32 type = 0;
if (creature->IsTabardDesigner())
{
// if tabard designer, then trying to buy a guild charter.
// do not let if already in guild.
if (_player->GetGuildId())
return;
charterid = GUILD_CHARTER;
cost = sWorld->getIntConfig(CONFIG_CHARTER_COST_GUILD);
type = GUILD_CHARTER_TYPE;
}
else
{
/// @todo find correct opcode
if (_player->getLevel() < sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
{
SendNotification(LANG_ARENA_ONE_TOOLOW, sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL));
return;
}
switch (clientIndex) // arenaSlot+1 as received from client (1 from 3 case)
{
case 1:
charterid = ARENA_TEAM_CHARTER_2v2;
cost = sWorld->getIntConfig(CONFIG_CHARTER_COST_ARENA_2v2);
type = ARENA_TEAM_CHARTER_2v2_TYPE;
break;
case 2:
charterid = ARENA_TEAM_CHARTER_3v3;
cost = sWorld->getIntConfig(CONFIG_CHARTER_COST_ARENA_3v3);
type = ARENA_TEAM_CHARTER_3v3_TYPE;
break;
case 3:
charterid = ARENA_TEAM_CHARTER_5v5;
cost = sWorld->getIntConfig(CONFIG_CHARTER_COST_ARENA_5v5);
type = ARENA_TEAM_CHARTER_5v5_TYPE;
break;
default:
TC_LOG_DEBUG("network", "unknown selection at buy arena petition: %u", clientIndex);
return;
}
if (_player->GetArenaTeamId(clientIndex - 1)) // arenaSlot+1 as received from client
{
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, name, "", ERR_ALREADY_IN_ARENA_TEAM);
return;
}
}
if (type == GUILD_CHARTER_TYPE)
{
if (sGuildMgr->GetGuildByName(name))
{
Guild::SendCommandResult(this, GUILD_COMMAND_CREATE, ERR_GUILD_NAME_EXISTS_S, name);
return;
}
if (sObjectMgr->IsReservedName(name) || !ObjectMgr::IsValidCharterName(name))
{
Guild::SendCommandResult(this, GUILD_COMMAND_CREATE, ERR_GUILD_NAME_INVALID, name);
return;
}
}
else
{
if (sArenaTeamMgr->GetArenaTeamByName(name))
{
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, name, "", ERR_ARENA_TEAM_NAME_EXISTS_S);
return;
}
if (sObjectMgr->IsReservedName(name) || !ObjectMgr::IsValidCharterName(name))
{
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, name, "", ERR_ARENA_TEAM_NAME_INVALID);
return;
}
}
ItemTemplate const* pProto = sObjectMgr->GetItemTemplate(charterid);
if (!pProto)
{
_player->SendBuyError(BUY_ERR_CANT_FIND_ITEM, NULL, charterid, 0);
return;
}
if (!_player->HasEnoughMoney(cost))
{ //player hasn't got enough money
_player->SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, creature, charterid, 0);
return;
}
ItemPosCountVec dest;
InventoryResult msg = _player->CanStoreNewItem(NULL_BAG, NULL_SLOT, dest, charterid, pProto->BuyCount);
if (msg != EQUIP_ERR_OK)
{
_player->SendEquipError(msg, NULL, NULL, charterid);
return;
}
_player->ModifyMoney(-(int32)cost);
Item* charter = _player->StoreNewItem(dest, charterid, true);
if (!charter)
return;
charter->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1, charter->GetGUID().GetCounter());
// ITEM_FIELD_ENCHANTMENT_1_1 is guild/arenateam id
// ITEM_FIELD_ENCHANTMENT_1_1+1 is current signatures count (showed on item)
charter->SetState(ITEM_CHANGED, _player);
_player->SendNewItem(charter, 1, true, false);
// a petition is invalid, if both the owner and the type matches
// we checked above, if this player is in an arenateam, so this must be
// datacorruption
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_PETITION_BY_OWNER);
stmt->setUInt32(0, _player->GetGUID().GetCounter());
stmt->setUInt8(1, type);
PreparedQueryResult result = CharacterDatabase.Query(stmt);
std::ostringstream ssInvalidPetitionGUIDs;
if (result)
{
do
{
Field* fields = result->Fetch();
ssInvalidPetitionGUIDs << '\'' << fields[0].GetUInt32() << "', ";
} while (result->NextRow());
}
// delete petitions with the same guid as this one
ssInvalidPetitionGUIDs << '\'' << charter->GetGUID().GetCounter() << '\'';
TC_LOG_DEBUG("network", "Invalid petition GUIDs: %s", ssInvalidPetitionGUIDs.str().c_str());
CharacterDatabase.EscapeString(name);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
trans->PAppend("DELETE FROM petition WHERE petitionguid IN (%s)", ssInvalidPetitionGUIDs.str().c_str());
trans->PAppend("DELETE FROM petition_sign WHERE petitionguid IN (%s)", ssInvalidPetitionGUIDs.str().c_str());
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PETITION);
stmt->setUInt32(0, _player->GetGUID().GetCounter());
stmt->setUInt32(1, charter->GetGUID().GetCounter());
stmt->setString(2, name);
stmt->setUInt8(3, uint8(type));
trans->Append(stmt);
CharacterDatabase.CommitTransaction(trans);
}
// Charter part
void WorldSession::HandleCharterBuy(WorldPacket & recv_data)
{
/*
{CLIENT} Packet: (0x01BD) CMSG_PETITION_BUY PacketSize = 85
|------------------------------------------------|----------------|
|00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F |0123456789ABCDEF|
|------------------------------------------------|----------------|
|50 91 00 00 6E 13 01 F0 00 00 00 00 00 00 00 00 |P...n...........|
|00 00 00 00 53 74 6F 72 6D 62 72 69 6E 67 65 72 |....Stormbringer|
|73 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |s...............|
|00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
|00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00 |................|
|00 00 00 00 00 |..... |
-------------------------------------------------------------------
*/
if(!_player->IsInWorld())
return;
uint64 creature_guid;
uint64 crap;
uint32 crap2;
string name;
uint8 error;
uint32 crap3,crap4,crap5,crap6,crap7,crap8,crap9,crap10,crap11,arena_index,crap12;
uint16 crap13;
uint8 crap14;
uint32 crap15;
recv_data >> creature_guid >> crap >> crap2 >> name;
recv_data >> crap3 >> crap4 >> crap5 >> crap6 >> crap7 >> crap8 >> crap9 >> crap10 >> crap11
>> crap12 >> crap13 >> crap14 >> arena_index >> crap15;
Creature * crt = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(creature_guid));
if(!crt)
{
Disconnect();
return;
}
if(crt->GetEntry()==19861 || crt->GetEntry()==18897 || crt->GetEntry()==19856 || crt->GetEntry()==sWorld.m_CustomCharterGiver ) /* i am lazy! */
{
uint32 arena_type = arena_index - 1;
if(arena_type > 2)
return;
if(_player->m_arenaTeams[arena_type] || _player->m_charters[arena_index])
{
SendNotification(_player->GetSession()->LocalizedWorldSrv(71));
return;
}
ArenaTeam * t = objmgr.GetArenaTeamByName(name, arena_type);
if(t != NULL)
{
sChatHandler.SystemMessage(this,_player->GetSession()->LocalizedWorldSrv(72));
return;
}
if(objmgr.GetCharterByName(name, (CharterTypes)arena_index))
{
sChatHandler.SystemMessage(this,_player->GetSession()->LocalizedWorldSrv(72));
return;
}
if(_player->m_charters[arena_type])
{
SendNotification(_player->GetSession()->LocalizedWorldSrv(73));
return;
}
static uint32 item_ids[] = {ARENA_TEAM_CHARTER_2v2, ARENA_TEAM_CHARTER_3v3, ARENA_TEAM_CHARTER_5v5};
static uint32 costs[] = {ARENA_TEAM_CHARTER_2v2_COST,ARENA_TEAM_CHARTER_3v3_COST,ARENA_TEAM_CHARTER_5v5_COST};
if(_player->GetUInt32Value(PLAYER_FIELD_COINAGE) < costs[arena_type])
return; // error message needed here
ItemPrototype * ip = ItemPrototypeStorage.LookupEntry(item_ids[arena_type]);
ASSERT(ip);
SlotResult res = _player->GetItemInterface()->FindFreeInventorySlot(ip);
if(res.Result == 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(0, 0, INV_ERR_INVENTORY_FULL);
return;
}
error = _player->GetItemInterface()->CanReceiveItem(ip,1);
if(error)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL,NULL,error);
}
else
{
// Create the item and charter
Item * i = objmgr.CreateItem(item_ids[arena_type], _player);
Charter * c = objmgr.CreateCharter(_player->GetLowGUID(), (CharterTypes)arena_index);
c->GuildName = name;
c->ItemGuid = i->GetGUID();
i->SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
i->SetUInt32Value(ITEM_FIELD_FLAGS, 1);
i->SetUInt32Value(ITEM_FIELD_ENCHANTMENT, c->GetID());
i->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, 57813883);
if( !_player->GetItemInterface()->AddItemToFreeSlot(i) )
{
c->Destroy();
i->DeleteMe();
return;
}
c->SaveToDB();
/*WorldPacket data(45);
BuildItemPushResult(&data, _player->GetGUID(), ITEM_PUSH_TYPE_RECEIVE, 1, item_ids[arena_type], 0);
SendPacket(&data);*/
SendItemPushResult(i, false, true, false, true, _player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(), 1);
_player->ModUnsigned32Value(PLAYER_FIELD_COINAGE, -(int32)costs[arena_type]);
_player->m_charters[arena_index] = c;
_player->SaveToDB(false);
}
}
else
{
Guild * g = objmgr.GetGuildByGuildName(name);
Charter * c = objmgr.GetCharterByName(name, CHARTER_TYPE_GUILD);
if(g != 0 || c != 0)
{
SendNotification(_player->GetSession()->LocalizedWorldSrv(74));
return;
}
if(_player->m_charters[CHARTER_TYPE_GUILD])
{
SendNotification(_player->GetSession()->LocalizedWorldSrv(75));
return;
}
ItemPrototype * ip = ItemPrototypeStorage.LookupEntry(ITEM_ENTRY_GUILD_CHARTER);
assert(ip);
SlotResult res = _player->GetItemInterface()->FindFreeInventorySlot(ip);
if(res.Result == 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(0, 0, INV_ERR_INVENTORY_FULL);
return;
}
error = _player->GetItemInterface()->CanReceiveItem(ItemPrototypeStorage.LookupEntry(ITEM_ENTRY_GUILD_CHARTER),1);
if(error)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL,NULL,error);
}
else
{
// Meh...
WorldPacket data(SMSG_PLAY_OBJECT_SOUND, 12);
data << uint32(0x000019C2);
data << creature_guid;
SendPacket(&data);
// Create the item and charter
Item * i = objmgr.CreateItem(ITEM_ENTRY_GUILD_CHARTER, _player);
c = objmgr.CreateCharter(_player->GetLowGUID(), CHARTER_TYPE_GUILD);
c->GuildName = name;
c->ItemGuid = i->GetGUID();
i->SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
i->SetUInt32Value(ITEM_FIELD_FLAGS, 1);
i->SetUInt32Value(ITEM_FIELD_ENCHANTMENT, c->GetID());
i->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, 57813883);
if( !_player->GetItemInterface()->AddItemToFreeSlot(i) )
{
c->Destroy();
i->DeleteMe();
return;
}
c->SaveToDB();
/*data.clear();
data.resize(45);
BuildItemPushResult(&data, _player->GetGUID(), ITEM_PUSH_TYPE_RECEIVE, 1, ITEM_ENTRY_GUILD_CHARTER, 0);
SendPacket(&data);*/
SendItemPushResult(i, false, true, false, true, _player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(), 1);
_player->m_charters[CHARTER_TYPE_GUILD] = c;
_player->SaveToDB(false);
}
}
}
void MailDraft::SendMailTo(SQLTransaction& trans, MailReceiver const& receiver, MailSender const& sender, MailCheckMask checked, uint32 deliver_delay)
{
Player* pReceiver = receiver.GetPlayer(); // can be NULL
Player* pSender = sObjectMgr->GetPlayerByLowGUID(sender.GetSenderId());
if (pReceiver)
prepareItems(pReceiver, trans); // generate mail template items
uint32 mailId = sObjectMgr->GenerateMailID();
time_t deliver_time = time(NULL) + deliver_delay;
//expire time if COD 3 days, if no COD 30 days, if auction sale pending 1 hour
uint32 expire_delay;
// auction mail without any items and money
if (sender.GetMailMessageType() == MAIL_AUCTION && m_items.empty() && !m_money)
expire_delay = sWorld->getIntConfig(CONFIG_MAIL_DELIVERY_DELAY);
// default case: expire time if COD 3 days, if no COD 30 days (or 90 days if sender is a game master)
else
{
if (m_COD)
expire_delay = 3 * DAY;
else
expire_delay = pSender && pSender->IsGameMaster() ? 90 * DAY : 30 * DAY;
}
time_t expire_time = deliver_time + expire_delay;
// Add to DB
uint8 index = 0;
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_MAIL);
stmt->setUInt32( index, mailId);
stmt->setUInt8 (++index, uint8(sender.GetMailMessageType()));
stmt->setInt8 (++index, int8(sender.GetStationery()));
stmt->setUInt16(++index, GetMailTemplateId());
stmt->setUInt64(++index, sender.GetSenderId());
stmt->setUInt64(++index, receiver.GetPlayerGUIDLow());
stmt->setString(++index, GetSubject());
stmt->setString(++index, GetBody());
stmt->setBool (++index, !m_items.empty());
stmt->setUInt64(++index, uint64(expire_time));
stmt->setUInt64(++index, uint64(deliver_time));
stmt->setUInt64(++index, m_money);
stmt->setUInt64(++index, m_COD);
stmt->setUInt8 (++index, uint8(checked));
trans->Append(stmt);
for (MailItemMap::const_iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
{
Item* pItem = mailItemIter->second;
stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_MAIL_ITEM);
stmt->setUInt32(0, mailId);
stmt->setUInt64(1, pItem->GetGUID().GetCounter());
stmt->setUInt64(2, receiver.GetPlayerGUIDLow());
trans->Append(stmt);
}
// For online receiver update in game mail status and data
if (pReceiver)
{
pReceiver->AddNewMailDeliverTime(deliver_time);
if (pReceiver->IsMailsLoaded())
{
Mail* m = new Mail;
m->messageID = mailId;
m->mailTemplateId = GetMailTemplateId();
m->subject = GetSubject();
m->body = GetBody();
m->money = GetMoney();
m->COD = GetCOD();
for (MailItemMap::const_iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
{
Item* item = mailItemIter->second;
m->AddItem(item->GetGUID().GetCounter(), item->GetEntry());
}
m->messageType = sender.GetMailMessageType();
m->stationery = sender.GetStationery();
m->sender = sender.GetSenderId();
m->receiver = receiver.GetPlayerGUIDLow();
m->expire_time = expire_time;
m->deliver_time = deliver_time;
m->checked = checked;
m->state = MAIL_STATE_UNCHANGED;
pReceiver->AddMail(m); // to insert new mail to beginning of maillist
if (!m_items.empty())
{
for (MailItemMap::iterator mailItemIter = m_items.begin(); mailItemIter != m_items.end(); ++mailItemIter)
pReceiver->AddMItem(mailItemIter->second);
}
}
else if (!m_items.empty())
{
SQLTransaction temp = SQLTransaction(NULL);
deleteIncludedItems(temp);
}
}
else if (!m_items.empty())
{
SQLTransaction temp = SQLTransaction(NULL);
deleteIncludedItems(temp);
}
}
// Charter part
void WorldSession::HandleCharterBuy(WorldPacket & recv_data)
{
CHECK_PACKET_SIZE(recv_data, 8+8+4+1+5*8+2+1+4+4);
uint64 creature_guid;
uint64 unk1, unk3, unk4, unk5, unk6, unk7;
uint32 unk2;
std::string name;
uint16 unk8;
uint8 unk9;
uint32 arena_index;
uint32 unk10;
uint8 error;
recv_data >> creature_guid; // NPC GUID
recv_data >> unk1; // 0
recv_data >> unk2; // 0
recv_data >> name; // name
// recheck
CHECK_PACKET_SIZE(recv_data, 8+8+4+(name.size()+1)+5*8+2+1+4+4);
recv_data >> unk3; // 0
recv_data >> unk4; // 0
recv_data >> unk5; // 0
recv_data >> unk6; // 0
recv_data >> unk7; // 0
recv_data >> unk8; // 0
recv_data >> unk9; // 0
recv_data >> arena_index; // index
recv_data >> unk10; // 0
Creature* crt = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(creature_guid));
if(!crt)
{
Disconnect();
return;
}
if( arena_index >= NUM_CHARTER_TYPES )
return;
if( crt->IsArenaOrganizer() ) // All arena organizers should be allowed to create arena charter's
{
uint32 arena_type = arena_index - 1;
if(arena_type > 2)
return;
if(_player->m_playerInfo->arenaTeam[arena_type])
{
SendNotification("You are already in an arena team.");
return;
}
if(_player->m_playerInfo->charterId[arena_index] != 0)
{
SendNotification("You already have an arena charter of this type.");
return;
}
ArenaTeam * t = objmgr.GetArenaTeamByName(name, arena_type);
if(t != NULL)
{
sChatHandler.SystemMessage(this,"That name is already in use.");
return;
}
if(objmgr.GetCharterByName(name, (CharterTypes)arena_index))
{
sChatHandler.SystemMessage(this,"That name is already in use.");
return;
}
static uint32 item_ids[] = {ARENA_TEAM_CHARTER_2v2, ARENA_TEAM_CHARTER_3v3, ARENA_TEAM_CHARTER_5v5};
static uint32 costs[] = {ARENA_TEAM_CHARTER_2v2_COST,ARENA_TEAM_CHARTER_3v3_COST,ARENA_TEAM_CHARTER_5v5_COST};
if(_player->GetUInt32Value(PLAYER_FIELD_COINAGE) < costs[arena_type] && !sWorld.free_arena_teams)
return; // error message needed here
ItemPrototype * ip = ItemPrototypeStorage.LookupEntry(item_ids[arena_type]);
ASSERT(ip);
SlotResult res = _player->GetItemInterface()->FindFreeInventorySlot(ip);
if(res.Result == 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, INV_ERR_INVENTORY_FULL);
return;
}
error = _player->GetItemInterface()->CanReceiveItem(ip,1, NULL);
if(error)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL,NULL,error);
}
else
{
// Create the item and charter
Item* i = objmgr.CreateItem(item_ids[arena_type], _player);
Charter * c = objmgr.CreateCharter(_player->GetLowGUID(), (CharterTypes)arena_index);
c->GuildName = name;
c->ItemGuid = i->GetGUID();
i->SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
i->SetUInt32Value(ITEM_FIELD_FLAGS, 1);
i->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1, c->GetID());
i->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, 57813883);
if( !_player->GetItemInterface()->AddItemToFreeSlot(i) )
{
c->Destroy();
c = NULL;
i->Destructor();
i = NULL;
return;
}
c->SaveToDB();
SendItemPushResult(i, false, true, false, true, _player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(), 1);
if(!sWorld.free_arena_teams)
_player->ModUnsigned32Value(PLAYER_FIELD_COINAGE, -(int32)costs[arena_type]);
_player->m_playerInfo->charterId[arena_index] = c->GetID();
_player->SaveToDB(false);
}
}
else
{
if( _player->GetUInt32Value(PLAYER_FIELD_COINAGE) < 1000 && !sWorld.free_guild_charters )
{
SendNotification("You don't have enough money.");
return;
}
if(_player->m_playerInfo->charterId[CHARTER_TYPE_GUILD] != 0)
{
SendNotification("You already have a guild charter.");
return;
}
Guild * g = objmgr.GetGuildByGuildName(name);
Charter * c = objmgr.GetCharterByName(name, CHARTER_TYPE_GUILD);
if(g != 0 || c != 0)
{
SendNotification("A guild with that name already exists.");
return;
}
ItemPrototype * ip = ItemPrototypeStorage.LookupEntry(ITEM_ENTRY_GUILD_CHARTER);
assert(ip);
SlotResult res = _player->GetItemInterface()->FindFreeInventorySlot(ip);
if(res.Result == 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, INV_ERR_INVENTORY_FULL);
return;
}
error = _player->GetItemInterface()->CanReceiveItem(ItemPrototypeStorage.LookupEntry(ITEM_ENTRY_GUILD_CHARTER),1, NULL);
if(error)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL,NULL,error);
}
else
{
// Meh...
WorldPacket data(SMSG_PLAY_OBJECT_SOUND, 12);
data << uint32(0x000019C2);
data << creature_guid;
SendPacket(&data);
// Create the item and charter
Item* i = objmgr.CreateItem(ITEM_ENTRY_GUILD_CHARTER, _player);
c = objmgr.CreateCharter(_player->GetLowGUID(), CHARTER_TYPE_GUILD);
c->GuildName = name;
c->ItemGuid = i->GetGUID();
i->SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
i->SetUInt32Value(ITEM_FIELD_FLAGS, 1);
i->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1, c->GetID());
i->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, 57813883);
if( !_player->GetItemInterface()->AddItemToFreeSlot(i) )
{
c->Destroy();
i->Destructor();
return;
}
c->SaveToDB();
SendItemPushResult(i, false, true, false, true, _player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(), 1);
_player->m_playerInfo->charterId[CHARTER_TYPE_GUILD] = c->GetID();
// 10 silver
if(!sWorld.free_guild_charters)
_player->ModUnsigned32Value(PLAYER_FIELD_COINAGE, -1000);
_player->SaveToDB(false);
}
}
}
void WorldSession::HandleSendMail(WorldPacket& recv_data)
{
CHECK_INWORLD_RETURN
MailMessage msg;
uint64 gameobject;
uint32 unk2;
uint8 itemcount;
uint8 itemslot;
uint8 i;
uint64 itemguid;
std::vector< Item* > items;
std::vector< Item* >::iterator itr;
std::string recepient;
Item* pItem;
//uint32 err = MAIL_OK;
recv_data >> gameobject >> recepient;
recv_data >> msg.subject >> msg.body >> msg.stationery;
recv_data >> unk2 >> itemcount;
if (itemcount > MAIL_MAX_ITEM_SLOT || msg.body.find("%") != std::string::npos || msg.subject.find("%") != std::string::npos)
{
SendMailError(MAIL_ERR_INTERNAL_ERROR);
return;
}
// Search for the recipient
PlayerInfo* player = ObjectMgr::getSingleton().GetPlayerInfoByName(recepient.c_str());
if (player == NULL)
{
SendMailError(MAIL_ERR_RECIPIENT_NOT_FOUND);
return;
}
for (i = 0; i < itemcount; ++i)
{
recv_data >> itemslot;
recv_data >> itemguid;
pItem = _player->GetItemInterface()->GetItemByGUID(itemguid);
if (pItem == NULL || pItem->IsSoulbound() || pItem->IsConjured())
{
SendMailError(MAIL_ERR_INTERNAL_ERROR);
return;
}
if (pItem->IsAccountbound() && GetAccountId() != player->acct) // don't mail account-bound items to another account
{
WorldPacket data(SMSG_SEND_MAIL_RESULT, 16);
data << uint32(0);
data << uint32(0);
data << uint32(MAIL_ERR_BAG_FULL);
data << uint32(INV_ERR_ARTEFACTS_ONLY_FOR_OWN_CHARACTERS);
SendPacket(&data);
return;
}
items.push_back(pItem);
}
recv_data >> msg.money;
recv_data >> msg.cod;
///\todo left over: (TODO- FIX ME BURLEX!)
// uint32
// uint32
// uint8
bool interfaction = false;
if (sMailSystem.MailOption(MAIL_FLAG_CAN_SEND_TO_OPPOSITE_FACTION) || (HasGMPermissions() && sMailSystem.MailOption(MAIL_FLAG_CAN_SEND_TO_OPPOSITE_FACTION_GM)))
{
interfaction = true;
}
// Check we're sending to the same faction (disable this for testing)
if (player->team != _player->GetTeam() && !interfaction)
{
SendMailError(MAIL_ERR_NOT_YOUR_ALLIANCE);
return;
}
// Check if we're sending mail to ourselves
if (strcmp(player->name, _player->GetName()) == 0 && !GetPermissionCount())
{
SendMailError(MAIL_ERR_CANNOT_SEND_TO_SELF);
return;
}
if (msg.stationery == MAIL_STATIONERY_GM && !HasGMPermissions())
{
SendMailError(MAIL_ERR_INTERNAL_ERROR);
return;
}
// Instant delivery time by default.
msg.delivery_time = (uint32)UNIXTIME;
// Set up the cost
int32 cost = 0;
// Check for attached money
if (msg.money > 0)
cost += msg.money;
if (!sMailSystem.MailOption(MAIL_FLAG_DISABLE_POSTAGE_COSTS) && !(GetPermissionCount() && sMailSystem.MailOption(MAIL_FLAG_NO_COST_FOR_GM)))
{
cost += 30;
}
// check that we have enough in our backpack
if (!_player->HasGold(cost))
{
SendMailError(MAIL_ERR_NOT_ENOUGH_MONEY);
return;
}
// Check for the item, and required item.
if (!items.empty())
{
for (itr = items.begin(); itr != items.end(); ++itr)
{
pItem = *itr;
if (_player->GetItemInterface()->SafeRemoveAndRetreiveItemByGuid(pItem->GetGUID(), false) != pItem)
continue; // should never be hit.
pItem->RemoveFromWorld();
pItem->SetOwner(NULL);
pItem->SaveToDB(INVENTORY_SLOT_NOT_SET, 0, true, NULL);
msg.items.push_back(pItem->GetLowGUID());
if (GetPermissionCount() > 0)
{
/* log the message */
sGMLog.writefromsession(this, "sent mail with item entry %u to %s, with gold %u.", pItem->GetEntry(), player->name, msg.money);
}
pItem->DeleteMe();
}
}
if (msg.money != 0 || msg.cod != 0 || (!msg.items.size() && player->acct != _player->GetSession()->GetAccountId()))
{
if (!sMailSystem.MailOption(MAIL_FLAG_DISABLE_HOUR_DELAY_FOR_ITEMS))
msg.delivery_time += 3600; // 1hr
}
// take the money
_player->ModGold(-cost);
// Fill in the rest of the info
msg.player_guid = player->guid;
msg.sender_guid = _player->GetGUID();
// 30 day expiry time for unread mail
if (!sMailSystem.MailOption(MAIL_FLAG_NO_EXPIRY))
msg.expire_time = (uint32)UNIXTIME + (TIME_DAY * MAIL_DEFAULT_EXPIRATION_TIME);
else
msg.expire_time = 0;
msg.deleted_flag = false;
msg.message_type = 0;
msg.checked_flag = msg.body.empty() ? MAIL_CHECK_MASK_COPIED : MAIL_CHECK_MASK_HAS_BODY;
// Great, all our info is filled in. Now we can add it to the other players mailbox.
sMailSystem.DeliverMessage(player->guid, &msg);
// Save/Update character's gold if they've received gold that is. This prevents a rollback.
CharacterDatabase.Execute("UPDATE characters SET gold = %u WHERE guid = %u", _player->GetGold(), _player->m_playerInfo->guid);
// Success packet :)
SendMailError(MAIL_OK);
}
void WorldSession::HandleSendMail(WorldPacket & recv_data )
{
MailMessage msg;
uint64 gameobject;
uint32 unk2;
uint8 itemcount;
uint8 itemslot;
uint8 i;
uint64 itemguid;
vector< Item* > items;
vector< Item* >::iterator itr;
string recepient;
Item * pItem;
//uint32 err = MAIL_OK;
recv_data >> gameobject >> recepient;
recv_data >> msg.subject >> msg.body >> msg.stationary;
recv_data >> unk2 >> itemcount;
//he simply ads ' ' after each '%' to string so that vsnprintf function would not find tokens in string
char *t=(char*)msg.subject.c_str();
if( t[0] != 0 ) //if not an empty string
{
int ind=1;
//make sure we do not have any recognizable tokens here
while(t[ind]!=0 && ind<5000)
{
if(t[ind-1]=='%')
t[ind]=' ';//just remove chars that could be interpreted
ind++;
}
}
msg.subject = t;
t=(char*)msg.body.c_str();
if( t[0] != 0 ) //if not an empty string
{
int ind=1;
while(t[ind]!=0 && ind<5000)
{
if(t[ind-1]=='%')
t[ind]=' ';//just remove chars that could be interpreted
ind++;
}
}
msg.body = t;
if( itemcount > 12 )
{
//SystemMessage("Sorry, Ascent does not support sending multiple items at this time. (don't want to lose your item do you) Remove some items, and try again.");
SendMailError(MAIL_ERR_INTERNAL_ERROR);
return;
}
for( i = 0; i < itemcount; ++i )
{
recv_data >> itemslot;
recv_data >> itemguid;
pItem = _player->GetItemInterface()->GetItemByGUID( itemguid );
if( pItem == NULL || pItem->IsSoulbound() || pItem->HasFlag( ITEM_FIELD_FLAGS, ITEM_FLAG_CONJURED ) )
{
SendMailError( MAIL_ERR_INTERNAL_ERROR );
return;
}
items.push_back( pItem );
}
recv_data >> msg.money;
recv_data >> msg.cod;
// left over: (TODO- FIX ME BURLEX!)
// uint32
// uint32
// uint8
// Search for the recipient
PlayerInfo* player = ObjectMgr::getSingleton().GetPlayerInfoByName(recepient.c_str());
if( player == NULL )
{
SendMailError( MAIL_ERR_RECIPIENT_NOT_FOUND );
return;
}
bool interfaction = false;
if( sMailSystem.MailOption( MAIL_FLAG_CAN_SEND_TO_OPPOSITE_FACTION ) || (HasGMPermissions() && sMailSystem.MailOption( MAIL_FLAG_CAN_SEND_TO_OPPOSITE_FACTION_GM ) ) )
{
interfaction = true;
}
// Check we're sending to the same faction (disable this for testing)
if( player->team != _player->GetTeam() && !interfaction )
{
SendMailError( MAIL_ERR_NOT_YOUR_ALLIANCE );
return;
}
// Check if we're sending mail to ourselves
if( strcmp(player->name, _player->GetName()) == 0 && !GetPermissionCount())
{
SendMailError(MAIL_ERR_CANNOT_SEND_TO_SELF);
return;
}
if( msg.stationary == 0x3d || msg.stationary == 0x3d && !HasGMPermissions())
{
SendMailError(MAIL_ERR_INTERNAL_ERROR);
return;
}
// Instant delivery time by default.
msg.delivery_time = (uint32)UNIXTIME;
// Set up the cost
int32 cost = 0;
if( !sMailSystem.MailOption( MAIL_FLAG_DISABLE_POSTAGE_COSTS ) && !( GetPermissionCount() && sMailSystem.MailOption( MAIL_FLAG_NO_COST_FOR_GM ) ) )
{
cost = 30;
}
// Check for attached money
if( msg.money > 0 )
cost += msg.money;
if( cost < 0 )
{
SendMailError(MAIL_ERR_INTERNAL_ERROR);
return;
}
// check that we have enough in our backpack
if( (int32)_player->GetUInt32Value( PLAYER_FIELD_COINAGE ) < cost )
{
SendMailError( MAIL_ERR_NOT_ENOUGH_MONEY );
return;
}
// Check for the item, and required item.
if( !items.empty( ) )
{
for( itr = items.begin(); itr != items.end(); ++itr )
{
pItem = *itr;
if( _player->GetItemInterface()->SafeRemoveAndRetreiveItemByGuid(pItem->GetGUID(), false) != pItem )
continue; // should never be hit.
pItem->RemoveFromWorld();
pItem->SetOwner( NULL );
pItem->SaveToDB( INVENTORY_SLOT_NOT_SET, 0, true, NULL );
msg.items.push_back( pItem->GetUInt32Value(OBJECT_FIELD_GUID) );
if( GetPermissionCount() > 0 )
{
/* log the message */
sGMLog.writefromsession(this, "sent mail with item entry %u to %s, with gold %u.", pItem->GetEntry(), player->name, msg.money);
}
pItem->DeleteMe();
}
}
if(msg.money != 0 || msg.cod != 0 || !msg.items.size() && player->acct != _player->GetSession()->GetAccountId())
{
if(!sMailSystem.MailOption(MAIL_FLAG_DISABLE_HOUR_DELAY_FOR_ITEMS))
msg.delivery_time += 3600; // 1hr
}
// take the money
_player->ModUnsigned32Value(PLAYER_FIELD_COINAGE, -cost);
// Fill in the rest of the info
msg.player_guid = player->guid;
msg.sender_guid = _player->GetGUID();
// 30 day expiry time for unread mail mail
if(!sMailSystem.MailOption(MAIL_FLAG_NO_EXPIRY))
msg.expire_time = (uint32)UNIXTIME + (TIME_DAY * MAIL_DEFAULT_EXPIRATION_TIME);
else
msg.expire_time = 0;
msg.copy_made = false;
msg.read_flag = false;
msg.deleted_flag = false;
msg.message_type = 0;
// Great, all our info is filled in. Now we can add it to the other players mailbox.
sMailSystem.DeliverMessage(player->guid, &msg);
// Success packet :)
SendMailError(MAIL_OK);
}
void WorldSession::HandleSellItemOpcode(WorldPacket & recv_data)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Received CMSG_SELL_ITEM");
uint64 vendorguid, itemguid;
uint32 count;
recv_data >> vendorguid >> itemguid >> count;
if (!itemguid)
return;
Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(vendorguid, UNIT_NPC_FLAG_VENDOR);
if (!creature)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: HandleSellItemOpcode - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(vendorguid)));
_player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, NULL, itemguid, 0);
return;
}
// remove fake death
if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
Item* pItem = _player->GetItemByGuid(itemguid);
if (pItem)
{
// prevent sell not owner item
if (_player->GetGUID() != pItem->GetOwnerGUID())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
return;
}
// prevent sell non empty bag by drag-and-drop at vendor's item list
if (pItem->IsNotEmptyBag())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
return;
}
// prevent sell currently looted item
if (_player->GetLootGUID() == pItem->GetGUID())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
return;
}
// prevent selling item for sellprice when the item is still refundable
// this probably happens when right clicking a refundable item, the client sends both
// CMSG_SELL_ITEM and CMSG_REFUND_ITEM (unverified)
if (pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_REFUNDABLE))
return; // Therefore, no feedback to client
// special case at auto sell (sell all)
if (count == 0)
{
count = pItem->GetCount();
}
else
{
// prevent sell more items that exist in stack (possible only not from client)
if (count > pItem->GetCount())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
return;
}
}
ItemTemplate const* pProto = pItem->GetTemplate();
if (pProto)
{
if (pProto->SellPrice > 0)
{
if (count < pItem->GetCount()) // need split items
{
Item* pNewItem = pItem->CloneItem(count, _player);
if (!pNewItem)
{
sLog->outError("WORLD: HandleSellItemOpcode - could not create clone of item %u; count = %u", pItem->GetEntry(), count);
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
return;
}
pItem->SetCount(pItem->GetCount() - count);
_player->ItemRemovedQuestCheck(pItem->GetEntry(), count);
if (_player->IsInWorld())
pItem->SendUpdateToPlayer(_player);
pItem->SetState(ITEM_CHANGED, _player);
_player->AddItemToBuyBackSlot(pNewItem);
if (_player->IsInWorld())
pNewItem->SendUpdateToPlayer(_player);
}
else
{
_player->ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
_player->RemoveItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
pItem->RemoveFromUpdateQueueOf(_player);
_player->AddItemToBuyBackSlot(pItem);
}
uint32 money = pProto->SellPrice * count;
_player->ModifyMoney(money);
_player->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_MONEY_FROM_VENDORS, money);
}
else
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, itemguid, 0);
return;
}
}
_player->SendSellError(SELL_ERR_CANT_FIND_ITEM, creature, itemguid, 0);
return;
}
// Charter part
void WorldSession::HandleCharterBuy(WorldPacket & recv_data)
{
uint8 error;
uint64 creature_guid;
uint32 crap;
uint64 crap2;
string name, unkstr;
uint32 Data[7];
uint16 crap10;
uint32 crap11;
uint32 crap12, PetitionSignerCount;
string crap13;
uint32 arena_index;
recv_data >> creature_guid;
recv_data >> crap >> crap2;
recv_data >> name >> unkstr;
recv_data >> Data[0] >> Data[1] >> Data[2] >> Data[3] >> Data[4] >> Data[5] >> Data[6];
recv_data >> crap10;
recv_data >> crap11 >> crap12 >> PetitionSignerCount;
for(uint32 s = 0; s < 10; ++s)
recv_data >> crap13;
recv_data >> arena_index;
Creature* crt = _player->GetMapMgr()->GetCreature(GET_LOWGUID_PART(creature_guid));
if(!crt)
{
Disconnect();
return;
}
if( arena_index >= NUM_CHARTER_TYPES )
return;
//All arena organizers should be allowed to create arena charter's
if( !crt->ArenaOrganizersFlags() )
{
uint32 arena_type = arena_index - 1;
if(arena_type > 2)
return;
if(_player->m_playerInfo->arenaTeam[arena_type])
{
SendNotification("You are already in an arena team.");
return;
}
if(_player->m_playerInfo->charterId[arena_index] != 0)
{
SendNotification("You already have an arena charter of this type.");
return;
}
if(!sWorld.VerifyName(name.c_str(), name.length()))
{
SendNotification("That name is invalid or contains invalid characters.");
return;
}
ArenaTeam * t = objmgr.GetArenaTeamByName(name, arena_type);
if(t != NULL)
{
sChatHandler.SystemMessage(this,"That name is already in use.");
return;
}
if(objmgr.GetCharterByName(name, (CharterTypes)arena_index))
{
sChatHandler.SystemMessage(this,"That name is already in use.");
return;
}
static uint32 item_ids[] = {ARENA_TEAM_CHARTER_2v2, ARENA_TEAM_CHARTER_3v3, ARENA_TEAM_CHARTER_5v5};
static uint32 costs[] = {ARENA_TEAM_CHARTER_2v2_COST,ARENA_TEAM_CHARTER_3v3_COST,ARENA_TEAM_CHARTER_5v5_COST};
if(_player->GetUInt32Value(PLAYER_FIELD_COINAGE) < costs[arena_type])
{
sChatHandler.SystemMessage(this,"You don't have enough money!");
return; // error message needed here
}
ItemPrototype * ip = ItemPrototypeStorage.LookupEntry(item_ids[arena_type]);
ASSERT(ip);
SlotResult res = _player->GetItemInterface()->FindFreeInventorySlot(ip);
if(res.Result == 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULLITEM, NULLITEM, INV_ERR_INVENTORY_FULL);
return;
}
error = _player->GetItemInterface()->CanReceiveItem(ip,1, NULL);
if(error)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULLITEM, NULLITEM,error);
}
else
{
// Create the item and charter
Item* i = objmgr.CreateItem(item_ids[arena_type], _player);
Charter * c = objmgr.CreateCharter(_player->GetLowGUID(), (CharterTypes)arena_index);
c->GuildName = name;
c->ItemGuid = i->GetGUID();
i->Bind(ITEM_BIND_ON_PICKUP);
i->SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
i->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1, c->GetID());
i->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, 57813883);
if( !_player->GetItemInterface()->AddItemToFreeSlot(i) )
{
c->Destroy();
c = NULL;
i->DeleteMe();
i = NULL;
return;
}
c->SaveToDB();
SendItemPushResult(i, false, true, false, true, _player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(), 1);
_player->ModUnsigned32Value(PLAYER_FIELD_COINAGE, -(int32)costs[arena_type]);
_player->m_playerInfo->charterId[arena_index] = c->GetID();
_player->SaveToDB(false);
}
}
else
{
if( _player->GetUInt32Value(PLAYER_FIELD_COINAGE) < 1000)
{
SendNotification("You don't have enough money.");
return;
}
if(_player->m_playerInfo->charterId[CHARTER_TYPE_GUILD] != 0)
{
SendNotification("You already have a guild charter.");
return;
}
if(!sWorld.VerifyName(name.c_str(), name.length()))
{
SendNotification("That name is invalid or contains invalid characters.");
return;
}
Guild * g = objmgr.GetGuildByGuildName(name);
Charter * c = objmgr.GetCharterByName(name, CHARTER_TYPE_GUILD);
if(g != 0 || c != 0)
{
SendNotification("A guild with that name already exists.");
return;
}
ItemPrototype * ip = ItemPrototypeStorage.LookupEntry(ITEM_ENTRY_GUILD_CHARTER);
assert(ip);
SlotResult res = _player->GetItemInterface()->FindFreeInventorySlot(ip);
if(res.Result == 0)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULLITEM, NULLITEM, INV_ERR_INVENTORY_FULL);
return;
}
error = _player->GetItemInterface()->CanReceiveItem(ItemPrototypeStorage.LookupEntry(ITEM_ENTRY_GUILD_CHARTER),1, NULL);
if(error)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULLITEM, NULLITEM,error);
}
else
{
// Meh...
WorldPacket data(SMSG_PLAY_OBJECT_SOUND, 12);
data << uint32(0x000019C2);
data << creature_guid;
SendPacket(&data);
// Create the item and charter
Item * i = objmgr.CreateItem(ITEM_ENTRY_GUILD_CHARTER, _player);
c = objmgr.CreateCharter(_player->GetLowGUID(), CHARTER_TYPE_GUILD);
c->GuildName = name;
c->ItemGuid = i->GetGUID();
i->Bind(ITEM_BIND_ON_PICKUP);
i->SetUInt32Value(ITEM_FIELD_STACK_COUNT, 1);
i->SetUInt32Value(ITEM_FIELD_ENCHANTMENT_1_1, c->GetID());
i->SetUInt32Value(ITEM_FIELD_PROPERTY_SEED, 57813883);
if( !_player->GetItemInterface()->AddItemToFreeSlot(i) )
{
c->Destroy();
c = NULL;
i->DeleteMe();
i = NULL;
return;
}
c->SaveToDB();
SendItemPushResult(i, false, true, false, true, _player->GetItemInterface()->LastSearchItemBagSlot(), _player->GetItemInterface()->LastSearchItemSlot(), 1);
_player->m_playerInfo->charterId[CHARTER_TYPE_GUILD] = c->GetID();
// 10 silver
_player->ModUnsigned32Value(PLAYER_FIELD_COINAGE, -1000);
_player->SaveToDB(false);
}
}
}
//called when player lists his received mails
void WorldSession::HandleGetMailList(WorldPacket& recvData)
{
ObjectGuid mailbox;
recvData >> mailbox;
if (!CanOpenMailBox(mailbox))
return;
Player* player = _player;
//load players mails, and mailed items
if (!player->m_mailsLoaded)
player->_LoadMail();
// client can't work with packets > max int16 value
const uint32 maxPacketSize = 32767;
uint32 mailsCount = 0; // real send to client mails amount
uint32 realCount = 0; // real mails amount
WorldPacket data(SMSG_MAIL_LIST_RESULT, (200)); // guess size
data << uint32(0); // real mail's count
data << uint8(0); // mail's count
time_t cur_time = time(nullptr);
for (PlayerMails::iterator itr = player->GetMailBegin(); itr != player->GetMailEnd(); ++itr)
{
// Only first 50 mails are displayed
if (mailsCount >= 50)
{
realCount += 1;
continue;
}
// skip deleted or not delivered (deliver delay not expired) mails
if ((*itr)->state == MAIL_STATE_DELETED || cur_time < (*itr)->deliver_time)
continue;
uint8 item_count = (*itr)->items.size(); // max count is MAX_MAIL_ITEMS (12)
size_t next_mail_size = 2+4+1+((*itr)->messageType == MAIL_NORMAL ? 8 : 4)+4*8+((*itr)->subject.size()+1)+((*itr)->body.size()+1)+1+item_count*(1+4+4+MAX_INSPECTED_ENCHANTMENT_SLOT*3*4+4+4+4+4+4+4+1);
if (data.wpos()+next_mail_size > maxPacketSize)
{
realCount += 1;
continue;
}
data << uint16(next_mail_size); // Message size
data << uint32((*itr)->messageID); // Message ID
data << uint8((*itr)->messageType); // Message Type
switch ((*itr)->messageType)
{
case MAIL_NORMAL: // sender guid
data << ObjectGuid(HighGuid::Player, (*itr)->sender);
break;
case MAIL_CREATURE:
case MAIL_GAMEOBJECT:
case MAIL_AUCTION:
case MAIL_CALENDAR:
data << uint32((*itr)->sender); // creature/gameobject entry, auction id, calendar event id?
break;
}
data << uint32((*itr)->COD); // COD
data << uint32(0); // package (Package.dbc)
data << uint32((*itr)->stationery); // stationery (Stationery.dbc)
data << uint32((*itr)->money); // Gold
data << uint32((*itr)->checked); // flags
data << float(float((*itr)->expire_time-time(nullptr))/DAY); // Time
data << uint32((*itr)->mailTemplateId); // mail template (MailTemplate.dbc)
data << (*itr)->subject; // Subject string - once 00, when mail type = 3, max 256
data << (*itr)->body; // message? max 8000
data << uint8(item_count); // client limit is 0x10
for (uint8 i = 0; i < item_count; ++i)
{
Item* item = player->GetMItem((*itr)->items[i].item_guid);
// item index (0-6?)
data << uint8(i);
// item guid low?
data << uint32((item ? item->GetGUID().GetCounter() : 0));
// entry
data << uint32((item ? item->GetEntry() : 0));
for (uint8 j = 0; j < MAX_INSPECTED_ENCHANTMENT_SLOT; ++j)
{
data << uint32((item ? item->GetEnchantmentId((EnchantmentSlot)j) : 0));
data << uint32((item ? item->GetEnchantmentDuration((EnchantmentSlot)j) : 0));
data << uint32((item ? item->GetEnchantmentCharges((EnchantmentSlot)j) : 0));
}
// can be negative
data << int32((item ? item->GetItemRandomPropertyId() : 0));
// unk
data << uint32((item ? item->GetItemSuffixFactor() : 0));
// stack count
data << uint32((item ? item->GetCount() : 0));
// charges
data << uint32((item ? item->GetSpellCharges() : 0));
// durability
data << uint32((item ? item->GetUInt32Value(ITEM_FIELD_MAXDURABILITY) : 0));
// durability
data << uint32((item ? item->GetUInt32Value(ITEM_FIELD_DURABILITY) : 0));
// unknown wotlk
data << uint8(0);
}
++realCount;
++mailsCount;
}
data.put<uint32>(0, realCount); // this will display warning about undelivered mail to player if realCount > mailsCount
data.put<uint8>(4, mailsCount); // set real send mails to client
SendPacket(&data);
// recalculate m_nextMailDelivereTime and unReadMails
_player->UpdateNextMailTimeAndUnreads();
}
void LootRoll::Finalize()
{
if( !mLootLock.AttemptAcquire() ) // only one finalization, please. players on different maps can roll, too, so this is needed.
{
sEventMgr.RemoveEvents(this);
return;
}
sEventMgr.RemoveEvents(this);
// this we will have to finalize with groups types.. for now
// we'll just assume need before greed. person with highest roll
// in need gets the item.
uint32 highest = 0;
int8 hightype = -1;
uint64 player = 0;
WorldPacket data(34);
for(std::map<uint32, uint32>::iterator itr = m_NeedRolls.begin(); itr != m_NeedRolls.end(); itr++)
{
if(itr->second > highest)
{
highest = itr->second;
player = itr->first;
hightype = NEED;
}
}
if(!highest)
{
for(std::map<uint32, uint32>::iterator itr = m_GreedRolls.begin(); itr != m_GreedRolls.end(); itr++)
{
if(itr->second > highest)
{
highest = itr->second;
player = itr->first;
hightype = GREED;
}
}
}
Loot * pLoot = 0;
uint32 guidtype = GET_TYPE_FROM_GUID(_guid);
if( guidtype == HIGHGUID_TYPE_UNIT )
{
Creature* pc = _mgr->GetCreature(GET_LOWGUID_PART(_guid));
if(pc) pLoot = &pc->m_loot;
}
else if( guidtype == HIGHGUID_TYPE_GAMEOBJECT )
{
GameObject* go = _mgr->GetGameObject(GET_LOWGUID_PART(_guid));
if(go) pLoot = &go->m_loot;
}
if(!pLoot)
{
delete this;
return;
}
if(_slotid >= pLoot->items.size())
{
delete this;
return;
}
pLoot->items.at(_slotid).roll = NULL;
uint32 itemid = pLoot->items.at(_slotid).item.itemproto->ItemId;
uint32 amt = pLoot->items.at(_slotid).iItemsCount;
if(!amt)
{
delete this;
return;
}
Player* _player = (player) ? _mgr->GetPlayer((uint32)player) : NULL;
if(!player || !_player)
{
/* all passed */
data.Initialize(SMSG_LOOT_ALL_PASSED);
data << _guid << _groupcount << _itemid << _randomsuffixid << _randompropertyid;
set<uint32>::iterator pitr = m_passRolls.begin();
while(_player == NULL && pitr != m_passRolls.end())
_player = _mgr->GetPlayer( (*(pitr++)) );
if( _player != NULL )
{
if(_player->InGroup())
_player->GetGroup()->SendPacketToAll(&data);
else
_player->GetSession()->SendPacket(&data);
}
/* item can now be looted by anyone :) */
pLoot->items.at(_slotid).passed = true;
delete this;
return;
}
pLoot->items.at(_slotid).roll = 0;
data.Initialize(SMSG_LOOT_ROLL_WON);
data << _guid << _slotid << _itemid << _randomsuffixid << _randompropertyid;
data << _player->GetGUID() << uint8(highest) << uint8(hightype);
if(_player->InGroup())
_player->GetGroup()->SendPacketToAll(&data);
else
_player->GetSession()->SendPacket(&data);
ItemPrototype* it = ItemPrototypeStorage.LookupEntry(itemid);
int8 error;
if((error = _player->GetItemInterface()->CanReceiveItem(it, 1, NULL)))
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, error);
return;
}
Item* add = _player->GetItemInterface()->FindItemLessMax(itemid, amt, false);
if (!add)
{
SlotResult slotresult = _player->GetItemInterface()->FindFreeInventorySlot(it);
if(!slotresult.Result)
{
_player->GetItemInterface()->BuildInventoryChangeError(NULL, NULL, INV_ERR_INVENTORY_FULL);
return;
}
DEBUG_LOG("HandleAutostoreItem","AutoLootItem %u",itemid);
Item* item = objmgr.CreateItem( itemid, _player);
item->SetUInt32Value(ITEM_FIELD_STACK_COUNT,amt);
if(pLoot->items.at(_slotid).iRandomProperty!=NULL)
{
item->SetRandomProperty(pLoot->items.at(_slotid).iRandomProperty->ID);
item->ApplyRandomProperties(false);
}
else if(pLoot->items.at(_slotid).iRandomSuffix != NULL)
{
item->SetRandomSuffix(pLoot->items.at(_slotid).iRandomSuffix->id);
item->ApplyRandomProperties(false);
}
if( _player->GetItemInterface()->SafeAddItem(item,slotresult.ContainerSlot, slotresult.Slot) )
{
_player->GetSession()->SendItemPushResult(item,false,true,true,true,slotresult.ContainerSlot,slotresult.Slot,1);
sQuestMgr.OnPlayerItemPickup(_player,item);
}
else
{
item->Destructor();
}
}
else
{
add->SetCount(add->GetUInt32Value(ITEM_FIELD_STACK_COUNT) + amt);
add->m_isDirty = true;
sQuestMgr.OnPlayerItemPickup(_player,add);
_player->GetSession()->SendItemPushResult(add, false, true, true, false, _player->GetItemInterface()->GetBagSlotByGuid(add->GetGUID()), 0xFFFFFFFF, 1);
}
pLoot->items.at(_slotid).iItemsCount=0;
// this gets sent to all looters
data.Initialize(SMSG_LOOT_REMOVED);
data << uint8(_slotid);
Player* plr;
for(LooterSet::iterator itr = pLoot->looters.begin(); itr != pLoot->looters.end(); itr++)
{
if((plr = _player->GetMapMgr()->GetPlayer(*itr)))
plr->GetSession()->SendPacket(&data);
}
delete this;
}
void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket)
{
uint8 bagIndex, slot;
uint8 unk_flags; // flags (if 0x02 - some additional data are received)
uint8 cast_count; // next cast if exists (single or not)
uint64 item_guid;
uint32 glyphIndex; // something to do with glyphs?
uint32 spellid; // casted spell id
recvPacket >> bagIndex >> slot >> cast_count >> spellid >> item_guid >> glyphIndex >> unk_flags;
// TODO: add targets.read() check
Player* pUser = _player;
// ignore for remote control state
if (!pUser->IsSelfMover())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
return;
}
// reject fake data
if (glyphIndex >= MAX_GLYPH_SLOT_INDEX)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if (!pItem)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
if (pItem->GetGUID() != item_guid)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
DETAIL_LOG("WORLD: CMSG_USE_ITEM packet, bagIndex: %u, slot: %u, cast_count: %u, spellid: %u, Item: %u, glyphIndex: %u, unk_flags: %u, data length = %i", bagIndex, slot, cast_count, spellid, pItem->GetEntry(), glyphIndex, unk_flags, (uint32)recvPacket.size());
ItemPrototype const *proto = pItem->GetProto();
if (!proto)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// some item classes can be used only in equipped state
if (proto->InventoryType != INVTYPE_NON_EQUIP && !pItem->IsEquipped())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
uint8 msg = pUser->CanUseItem(pItem);
if (msg != EQUIP_ERR_OK)
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError( msg, pItem, NULL );
return;
}
// not allow use item from trade (cheat way only)
if (pItem->IsInTrade())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// only allow conjured consumable, bandage, poisons (all should have the 2^21 item flag set in DB)
if (proto->Class == ITEM_CLASS_CONSUMABLE &&
!(proto->Flags & ITEM_FLAG_USEABLE_IN_ARENA) &&
pUser->InArena())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_NOT_DURING_ARENA_MATCH,pItem,NULL);
return;
}
if (pUser->isInCombat())
{
for(int i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
{
if (SpellEntry const *spellInfo = sSpellStore.LookupEntry(proto->Spells[i].SpellId))
{
if (IsNonCombatSpell(spellInfo))
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_NOT_IN_COMBAT,pItem,NULL);
return;
}
}
}
// Prevent potion drink if another potion in processing (client have potions disabled in like case)
if (pItem->IsPotion() && pUser->GetLastPotionId())
{
recvPacket.rpos(recvPacket.wpos()); // prevent spam at not read packet tail
pUser->SendEquipError(EQUIP_ERR_OBJECT_IS_BUSY,pItem,NULL);
return;
}
}
// check also BIND_WHEN_PICKED_UP and BIND_QUEST_ITEM for .additem or .additemset case by GM (not binded at adding to inventory)
if( pItem->GetProto()->Bonding == BIND_WHEN_USE || pItem->GetProto()->Bonding == BIND_WHEN_PICKED_UP || pItem->GetProto()->Bonding == BIND_QUEST_ITEM )
{
if (!pItem->IsSoulBound())
{
pItem->SetState(ITEM_CHANGED, pUser);
pItem->SetBinding( true );
}
}
SpellCastTargets targets;
recvPacket >> targets.ReadForCaster(pUser);
targets.Update(pUser);
if (!pItem->IsTargetValidForItemUse(targets.getUnitTarget()))
{
// free gray item after use fail
pUser->SendEquipError(EQUIP_ERR_NONE, pItem, NULL);
// send spell error
if (SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid))
{
// for implicit area/coord target spells
if (IsPointEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_0])) ||
IsAreaEffectTarget(Targets(spellInfo->EffectImplicitTargetA[EFFECT_INDEX_0])))
Spell::SendCastResult(_player,spellInfo,cast_count,SPELL_FAILED_NO_VALID_TARGETS);
// for explicit target spells
else
Spell::SendCastResult(_player,spellInfo,cast_count,SPELL_FAILED_BAD_TARGETS);
}
return;
}
//Note: If script stop casting it must send appropriate data to client to prevent stuck item in gray state.
if (!sScriptMgr.OnItemUse(pUser, pItem, targets))
{
// no script or script not process request by self
pUser->CastItemUseSpell(pItem,targets,cast_count,glyphIndex);
}
}
void WorldSession::HandleAcceptTradeOpcode(WorldPacket& /*recvPacket*/)
{
TradeData* my_trade = _player->m_trade;
if (!my_trade)
return;
Player* trader = my_trade->GetTrader();
TradeData* his_trade = trader->m_trade;
if (!his_trade)
return;
Item *myItems[TRADE_SLOT_TRADED_COUNT] = { NULL, NULL, NULL, NULL, NULL, NULL };
Item *hisItems[TRADE_SLOT_TRADED_COUNT] = { NULL, NULL, NULL, NULL, NULL, NULL };
bool myCanCompleteTrade = true, hisCanCompleteTrade = true;
// set before checks for propertly undo at problems (it already set in to client)
my_trade->SetAccepted(true);
// not accept case incorrect money amount
if (!_player->HasEnoughMoney(my_trade->GetMoney()))
{
SendNotification(LANG_NOT_ENOUGH_GOLD);
my_trade->SetAccepted(false, true);
return;
}
// not accept case incorrect money amount
if (!trader->HasEnoughMoney(his_trade->GetMoney()))
{
trader->GetSession()->SendNotification(LANG_NOT_ENOUGH_GOLD);
his_trade->SetAccepted(false, true);
return;
}
// not accept if some items now can't be trade (cheating)
for (uint8 i = 0; i < TRADE_SLOT_TRADED_COUNT; ++i)
{
if (Item* item = my_trade->GetItem(TradeSlots(i)))
{
if (!item->CanBeTraded(false, true))
{
SendTradeStatus(TRADE_STATUS_TRADE_CANCELED);
return;
}
if (item->IsBindedNotWith(trader))
{
SendTradeStatus(TRADE_STATUS_NOT_ELIGIBLE);
SendTradeStatus(TRADE_STATUS_CLOSE_WINDOW/*TRADE_STATUS_TRADE_CANCELED*/);
return;
}
}
if (Item* item = his_trade->GetItem(TradeSlots(i)))
{
if (!item->CanBeTraded(false, true))
{
SendTradeStatus(TRADE_STATUS_TRADE_CANCELED);
return;
}
//if (item->IsBindedNotWith(_player)) // dont mark as invalid when his item isnt good (not exploitable because if item is invalid trade will fail anyway later on the same check)
//{
// SendTradeStatus(TRADE_STATUS_NOT_ELIGIBLE);
// his_trade->SetAccepted(false, true);
// return;
//}
}
}
if (his_trade->IsAccepted())
{
setAcceptTradeMode(my_trade, his_trade, myItems, hisItems);
Spell* my_spell = NULL;
SpellCastTargets my_targets;
Spell* his_spell = NULL;
SpellCastTargets his_targets;
// not accept if spell can't be casted now (cheating)
if (uint32 my_spell_id = my_trade->GetSpell())
{
SpellEntry const* spellEntry = sSpellStore.LookupEntry(my_spell_id);
Item* castItem = my_trade->GetSpellCastItem();
if (!spellEntry || !his_trade->GetItem(TRADE_SLOT_NONTRADED) ||
(my_trade->HasSpellCastItem() && !castItem))
{
clearAcceptTradeMode(my_trade, his_trade);
clearAcceptTradeMode(myItems, hisItems);
my_trade->SetSpell(0);
return;
}
my_spell = new Spell(_player, spellEntry, true);
my_spell->m_CastItem = castItem;
my_spell->m_castItemGUID = castItem ? castItem->GetGUID() : 0;
my_targets.setTradeItemTarget(_player);
my_spell->m_targets = my_targets;
SpellCastResult res = my_spell->CheckCast(true);
if (res != SPELL_CAST_OK)
{
my_spell->SendCastResult(res);
clearAcceptTradeMode(my_trade, his_trade);
clearAcceptTradeMode(myItems, hisItems);
delete my_spell;
my_trade->SetSpell(0);
return;
}
}
// not accept if spell can't be casted now (cheating)
if (uint32 his_spell_id = his_trade->GetSpell())
{
SpellEntry const* spellEntry = sSpellStore.LookupEntry(his_spell_id);
Item* castItem = his_trade->GetSpellCastItem();
if (!spellEntry || !my_trade->GetItem(TRADE_SLOT_NONTRADED) || (his_trade->HasSpellCastItem() && !castItem))
{
delete my_spell;
his_trade->SetSpell(0);
clearAcceptTradeMode(my_trade, his_trade);
clearAcceptTradeMode(myItems, hisItems);
return;
}
his_spell = new Spell(trader, spellEntry, true);
his_spell->m_CastItem = castItem;
his_spell->m_castItemGUID = castItem ? castItem->GetGUID() : 0;
his_targets.setTradeItemTarget(trader);
his_spell->m_targets = his_targets;
SpellCastResult res = his_spell->CheckCast(true);
if (res != SPELL_CAST_OK)
{
his_spell->SendCastResult(res);
clearAcceptTradeMode(my_trade, his_trade);
clearAcceptTradeMode(myItems, hisItems);
delete my_spell;
delete his_spell;
his_trade->SetSpell(0);
return;
}
}
// inform partner client
trader->GetSession()->SendTradeStatus(TRADE_STATUS_TRADE_ACCEPT);
// test if item will fit in each inventory
hisCanCompleteTrade = (trader->CanStoreItems(myItems, TRADE_SLOT_TRADED_COUNT) == EQUIP_ERR_OK);
myCanCompleteTrade = (_player->CanStoreItems(hisItems, TRADE_SLOT_TRADED_COUNT) == EQUIP_ERR_OK);
clearAcceptTradeMode(myItems, hisItems);
// in case of missing space report error
if (!myCanCompleteTrade)
{
clearAcceptTradeMode(my_trade, his_trade);
SendNotification(LANG_NOT_FREE_TRADE_SLOTS);
trader->GetSession()->SendNotification(LANG_NOT_PARTNER_FREE_TRADE_SLOTS);
my_trade->SetAccepted(false);
his_trade->SetAccepted(false);
return;
}
else if (!hisCanCompleteTrade)
{
clearAcceptTradeMode(my_trade, his_trade);
SendNotification(LANG_NOT_PARTNER_FREE_TRADE_SLOTS);
trader->GetSession()->SendNotification(LANG_NOT_FREE_TRADE_SLOTS);
my_trade->SetAccepted(false);
his_trade->SetAccepted(false);
return;
}
// execute trade: 1. remove
for (uint8 i = 0; i < TRADE_SLOT_TRADED_COUNT; ++i)
{
if (myItems[i])
{
myItems[i]->SetUInt64Value(ITEM_FIELD_GIFTCREATOR, _player->GetGUID());
_player->MoveItemFromInventory(myItems[i]->GetBagSlot(), myItems[i]->GetSlot(), true);
}
if (hisItems[i])
{
hisItems[i]->SetUInt64Value(ITEM_FIELD_GIFTCREATOR, trader->GetGUID());
trader->MoveItemFromInventory(hisItems[i]->GetBagSlot(), hisItems[i]->GetSlot(), true);
}
}
// execute trade: 2. store
moveItems(myItems, hisItems);
// logging money
if (sWorld->getBoolConfig(CONFIG_GM_LOG_TRADE))
{
if (_player->GetSession()->GetSecurity() > SEC_PLAYER && my_trade->GetMoney() > 0)
{
sLog->outCommand(_player->GetSession()->GetAccountId(),"GM %s (Account: %u) give money (Amount: %u) to player: %s (Account: %u)",
_player->GetName(), _player->GetSession()->GetAccountId(),
my_trade->GetMoney(),
trader->GetName(), trader->GetSession()->GetAccountId());
}
if (trader->GetSession()->GetSecurity() > SEC_PLAYER && his_trade->GetMoney() > 0)
{
sLog->outCommand(trader->GetSession()->GetAccountId(),"GM %s (Account: %u) give money (Amount: %u) to player: %s (Account: %u)",
trader->GetName(), trader->GetSession()->GetAccountId(),
his_trade->GetMoney(),
_player->GetName(), _player->GetSession()->GetAccountId());
}
}
// update money
_player->ModifyMoney(-int32(my_trade->GetMoney()));
_player->ModifyMoney(his_trade->GetMoney());
trader->ModifyMoney(-int32(his_trade->GetMoney()));
trader->ModifyMoney(my_trade->GetMoney());
if (my_spell)
my_spell->prepare(&my_targets);
if (his_spell)
his_spell->prepare(&his_targets);
// cleanup
clearAcceptTradeMode(my_trade, his_trade);
delete _player->m_trade;
_player->m_trade = NULL;
delete trader->m_trade;
trader->m_trade = NULL;
// desynchronized with the other saves here (SaveInventoryAndGoldToDB() not have own transaction guards)
SQLTransaction trans = CharacterDatabase.BeginTransaction();
_player->SaveInventoryAndGoldToDB(trans);
trader->SaveInventoryAndGoldToDB(trans);
CharacterDatabase.CommitTransaction(trans);
trader->GetSession()->SendTradeStatus(TRADE_STATUS_TRADE_COMPLETE);
SendTradeStatus(TRADE_STATUS_TRADE_COMPLETE);
}
else
{
trader->GetSession()->SendTradeStatus(TRADE_STATUS_TRADE_ACCEPT);
}
}
void GossipSelectOption(Object * pObject, Player* Plr, uint32 Id, uint32 IntId, const char * Code)
{
Creature * pCreature = (pObject->IsCreature())?((Creature*)pObject):NULL;
if( pCreature==NULL || Plr == NULL )
return;
uint32 ChosenItemSlot = IntId - 2;
if( ChosenItemSlot >= 0 && ChosenItemSlot < RENTED_ITEM_COUNT )
{
int64 *Reserved = pObject->GetCreateIn64Extension( GOLD_SINK_ITEM_NPC_ID + ChosenItemSlot * EXTENSION_ITEM_INFO_SIZE + EXTENSION_ITEM_INFO_INDEX_TIME );
//check if item is still reserved
if( *Reserved > UNIXTIME )
{
Plr->BroadcastMessage("Item got already reserved by someone else");
Plr->CloseGossip();
return;
}
//check if offering enough money for the item
//tell the player we have an item available if he agrees to pay more
int64 *Cost = pObject->GetCreateIn64Extension( GOLD_SINK_ITEM_NPC_ID + ChosenItemSlot * EXTENSION_ITEM_INFO_SIZE + EXTENSION_ITEM_INFO_INDEX_COST );
int32 NeededGold = ( RENTED_ITEM_MIN_GOLD + *Cost ) * ITEM_RESERVE_GOLD_INCREMENT_PCT / 100 * 10000;
int32 BetGoldAmount;
if( Code != NULL )
BetGoldAmount = atoi( Code ) * 10000;
else
BetGoldAmount = 0;
if( Plr->GetGold() < NeededGold || Plr->GetGold() < BetGoldAmount )
{
Plr->BroadcastMessage("You do not have enough gold");
Plr->CloseGossip();
return;
}
if( BetGoldAmount < NeededGold )
{
Plr->BroadcastMessage("You need to pay more then the other player to rent this item");
Plr->CloseGossip();
return;
}
Plr->ModGold( -BetGoldAmount );
//mark the new gold reserver limit
*Cost = NeededGold / 10000;
//avoid threading issues, lock this item asp
*Reserved = UNIXTIME + MINIMUM_RESERVE_MINUTES * 60;
//take the item away from the other player if possible
int64 *ItemGUID = pObject->GetCreateIn64Extension( GOLD_SINK_ITEM_NPC_ID + ChosenItemSlot * EXTENSION_ITEM_INFO_SIZE + EXTENSION_ITEM_INFO_INDEX_IGUID );
int64 *PlayerGUID = pObject->GetCreateIn64Extension( GOLD_SINK_ITEM_NPC_ID + ChosenItemSlot * EXTENSION_ITEM_INFO_SIZE + EXTENSION_ITEM_INFO_INDEX_PGUID );
{
ItemPrototype *iProto = ItemPrototypeStorage.LookupEntry( RentedItemIDs[ ChosenItemSlot ] );
char ItemLink[ 500 ];
GetItemLinkByProto(iProto, ItemLink );
RemoveItemFromPlayer( *PlayerGUID, *ItemGUID, pCreature, ItemLink );
}
//create and add a new item to the new player
/*
FILE *f = fopen( "gold.txt","at");
if( f )
{
fprintf( f, "Adding %d to %d at %d cost %d expire %d\n", RentedItemIDs[ ChosenItemSlot ], (uint32)Plr->GetGUID(), UNIXTIME, *Cost, *Reserved );
fclose( f );
}*/
Item *It = Plr->GetItemInterface()->AddItemById( RentedItemIDs[ ChosenItemSlot ], 1, 0 );
if( It )
{
*ItemGUID = It->GetGUID();
*PlayerGUID = Plr->GetGUID();
It->SetFlag( ITEM_FIELD_FLAGS, ITEM_FLAG_CONJURED );
}
}
Plr->CloseGossip();
}
void WorldSession::HandleSellItemOpcode(WorldPackets::Item::SellItem& packet)
{
TC_LOG_DEBUG("network", "WORLD: Received CMSG_SELL_ITEM: Vendor %s, Item %s, Amount: %u",
packet.VendorGUID.ToString().c_str(), packet.ItemGUID.ToString().c_str(), packet.Amount);
if (packet.ItemGUID.IsEmpty())
return;
Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.VendorGUID, UNIT_NPC_FLAG_VENDOR);
if (!creature)
{
TC_LOG_DEBUG("network", "WORLD: HandleSellItemOpcode - %s not found or you can not interact with him.", packet.VendorGUID.ToString().c_str());
_player->SendSellError(SELL_ERR_CANT_FIND_VENDOR, nullptr, packet.ItemGUID);
return;
}
// remove fake death
if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
Item* pItem = _player->GetItemByGuid(packet.ItemGUID);
if (pItem)
{
// prevent sell not owner item
if (_player->GetGUID() != pItem->GetOwnerGUID())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
return;
}
// prevent sell non empty bag by drag-and-drop at vendor's item list
if (pItem->IsNotEmptyBag())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
return;
}
// prevent sell currently looted item
if (_player->GetLootGUID() == pItem->GetGUID())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
return;
}
// prevent selling item for sellprice when the item is still refundable
// this probably happens when right clicking a refundable item, the client sends both
// CMSG_SELL_ITEM and CMSG_REFUND_ITEM (unverified)
if (pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_REFUNDABLE))
return; // Therefore, no feedback to client
// special case at auto sell (sell all)
if (packet.Amount == 0)
packet.Amount = pItem->GetCount();
else
{
// prevent sell more items that exist in stack (possible only not from client)
if (packet.Amount > pItem->GetCount())
{
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
return;
}
}
ItemTemplate const* pProto = pItem->GetTemplate();
if (pProto)
{
if (pProto->GetSellPrice() > 0)
{
if (packet.Amount < pItem->GetCount()) // need split items
{
Item* pNewItem = pItem->CloneItem(packet.Amount, _player);
if (!pNewItem)
{
TC_LOG_ERROR("network", "WORLD: HandleSellItemOpcode - could not create clone of item %u; count = %u", pItem->GetEntry(), packet.Amount);
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
return;
}
pItem->SetCount(pItem->GetCount() - packet.Amount);
_player->ItemRemovedQuestCheck(pItem->GetEntry(), packet.Amount);
if (_player->IsInWorld())
pItem->SendUpdateToPlayer(_player);
pItem->SetState(ITEM_CHANGED, _player);
_player->AddItemToBuyBackSlot(pNewItem);
if (_player->IsInWorld())
pNewItem->SendUpdateToPlayer(_player);
}
else
{
_player->ItemRemovedQuestCheck(pItem->GetEntry(), pItem->GetCount());
_player->RemoveItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
pItem->RemoveFromUpdateQueueOf(_player);
_player->AddItemToBuyBackSlot(pItem);
}
uint32 money = pProto->GetSellPrice() * packet.Amount;
_player->ModifyMoney(money);
_player->UpdateCriteria(CRITERIA_TYPE_MONEY_FROM_VENDORS, money);
}
else
_player->SendSellError(SELL_ERR_CANT_SELL_ITEM, creature, packet.ItemGUID);
return;
}
}
_player->SendSellError(SELL_ERR_CANT_FIND_ITEM, creature, packet.ItemGUID);
return;
}
void WorldSession::HandleOpenItemOpcode(WorldPacket& recvPacket)
{
CHECK_PACKET_SIZE(recvPacket,1+1);
sLog.outDetail("WORLD: CMSG_OPEN_ITEM packet, data length = %i",recvPacket.size());
Player* pUser = _player;
uint8 bagIndex, slot;
recvPacket >> bagIndex >> slot;
sLog.outDetail("bagIndex: %u, slot: %u",bagIndex,slot);
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if(!pItem)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
ItemPrototype const *proto = pItem->GetProto();
if(!proto)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// locked item
uint32 lockId = proto->LockID;
if(lockId)
{
LockEntry const *lockInfo = sLockStore.LookupEntry(lockId);
if (!lockInfo)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL );
sLog.outError( "WORLD::OpenItem: item [guid = %u] has an unknown lockId: %u!", pItem->GetGUIDLow() , lockId);
return;
}
// required picklocking
if(lockInfo->Skill[1] || lockInfo->Skill[0])
{
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL );
return;
}
}
if(pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED))// wrapped?
{
QueryResult *result = CharacterDatabase.PQuery("SELECT entry, flags FROM character_gifts WHERE item_guid = '%u'", pItem->GetGUIDLow());
if (result)
{
Field *fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
uint32 flags = fields[1].GetUInt32();
pItem->SetUInt64Value(ITEM_FIELD_GIFTCREATOR, 0);
pItem->SetEntry(entry);
pItem->SetUInt32Value(ITEM_FIELD_FLAGS, flags);
pItem->SetState(ITEM_CHANGED, pUser);
delete result;
}
else
{
sLog.outError("Wrapped item %u don't have record in character_gifts table and will deleted", pItem->GetGUIDLow());
pUser->DestroyItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
return;
}
CharacterDatabase.PExecute("DELETE FROM character_gifts WHERE item_guid = '%u'", pItem->GetGUIDLow());
}
else
pUser->SendLoot(pItem->GetGUID(),LOOT_CORPSE);
}
void WorldSession::HandleWrapItem(WorldPackets::Item::WrapItem& packet)
{
if (packet.Inv.Items.size() != 2)
{
TC_LOG_ERROR("network", "HandleWrapItem - Invalid itemCount (" SZFMTD ")", packet.Inv.Items.size());
return;
}
/// @todo: 6.x find better way for read
// Gift
uint8 giftContainerSlot = packet.Inv.Items[0].ContainerSlot;
uint8 giftSlot = packet.Inv.Items[0].Slot;
// Item
uint8 itemContainerSlot = packet.Inv.Items[1].ContainerSlot;
uint8 itemSlot = packet.Inv.Items[1].Slot;
TC_LOG_DEBUG("network", "HandleWrapItem - Receive giftContainerSlot = %u, giftSlot = %u, itemContainerSlot = %u, itemSlot = %u", giftContainerSlot, giftSlot, itemContainerSlot, itemSlot);
Item* gift = _player->GetItemByPos(giftContainerSlot, giftSlot);
if (!gift)
{
_player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
return;
}
if (!(gift->GetTemplate()->GetFlags() & ITEM_FLAG_IS_WRAPPER)) // cheating: non-wrapper wrapper
{
_player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, gift, NULL);
return;
}
Item* item = _player->GetItemByPos(itemContainerSlot, itemSlot);
if (!item)
{
_player->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, item, NULL);
return;
}
if (item == gift) // not possable with pacjket from real client
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_WRAPPED, item, NULL);
return;
}
if (item->IsEquipped())
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_EQUIPPED, item, NULL);
return;
}
if (!item->GetGuidValue(ITEM_FIELD_GIFTCREATOR).IsEmpty()) // HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED);
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_WRAPPED, item, NULL);
return;
}
if (item->IsBag())
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_BAGS, item, NULL);
return;
}
if (item->IsSoulBound())
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_BOUND, item, NULL);
return;
}
if (item->GetMaxStackCount() != 1)
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_STACKABLE, item, NULL);
return;
}
// maybe not correct check (it is better than nothing)
if (item->GetTemplate()->GetMaxCount() > 0)
{
_player->SendEquipError(EQUIP_ERR_CANT_WRAP_UNIQUE, item, NULL);
return;
}
SQLTransaction trans = CharacterDatabase.BeginTransaction();
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHAR_GIFT);
stmt->setUInt64(0, item->GetOwnerGUID().GetCounter());
stmt->setUInt64(1, item->GetGUID().GetCounter());
stmt->setUInt32(2, item->GetEntry());
stmt->setUInt32(3, item->GetUInt32Value(ITEM_FIELD_FLAGS));
trans->Append(stmt);
item->SetEntry(gift->GetEntry());
switch (item->GetEntry())
{
case 5042:
item->SetEntry(5043);
break;
case 5048:
item->SetEntry(5044);
break;
case 17303:
item->SetEntry(17302);
break;
case 17304:
item->SetEntry(17305);
break;
case 17307:
item->SetEntry(17308);
break;
case 21830:
item->SetEntry(21831);
break;
}
item->SetGuidValue(ITEM_FIELD_GIFTCREATOR, _player->GetGUID());
item->SetUInt32Value(ITEM_FIELD_FLAGS, ITEM_FIELD_FLAG_WRAPPED);
item->SetState(ITEM_CHANGED, _player);
if (item->GetState() == ITEM_NEW) // save new item, to have alway for `character_gifts` record in `item_instance`
{
// after save it will be impossible to remove the item from the queue
item->RemoveFromUpdateQueueOf(_player);
item->SaveToDB(trans); // item gave inventory record unchanged and can be save standalone
}
CharacterDatabase.CommitTransaction(trans);
uint32 count = 1;
_player->DestroyItemCount(gift, count, true);
}
void WorldSession::HandleSellItemOpcode( WorldPacket & recv_data )
{
sLog.outDebug( "WORLD: Received CMSG_SELL_ITEM" );
uint64 vendorguid, itemguid;
uint8 _count;
recv_data >> vendorguid >> itemguid >> _count;
// prevent possible overflow, as mangos uses uint32 for item count
uint32 count = _count;
if(!itemguid)
return;
Creature *pCreature = GetPlayer()->GetNPCIfCanInteractWith(vendorguid,UNIT_NPC_FLAG_VENDOR);
if (!pCreature)
{
sLog.outDebug( "WORLD: HandleSellItemOpcode - Unit (GUID: %u) not found or you can't interact with him.", uint32(GUID_LOPART(vendorguid)) );
_player->SendSellError( SELL_ERR_CANT_FIND_VENDOR, NULL, itemguid, 0);
return;
}
// remove fake death
if(GetPlayer()->hasUnitState(UNIT_STAT_DIED))
GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH);
Item *pItem = _player->GetItemByGuid( itemguid );
if( pItem )
{
// prevent sell not owner item
if(_player->GetGUID()!=pItem->GetOwnerGUID())
{
_player->SendSellError( SELL_ERR_CANT_SELL_ITEM, pCreature, itemguid, 0);
return;
}
// prevent sell non empty bag by drag-and-drop at vendor's item list
if(pItem->IsBag() && !((Bag*)pItem)->IsEmpty())
{
_player->SendSellError( SELL_ERR_CANT_SELL_ITEM, pCreature, itemguid, 0);
return;
}
// prevent sell currently looted item
if(_player->GetLootGUID()==pItem->GetGUID())
{
_player->SendSellError( SELL_ERR_CANT_SELL_ITEM, pCreature, itemguid, 0);
return;
}
// special case at auto sell (sell all)
if(count==0)
{
count = pItem->GetCount();
}
else
{
// prevent sell more items that exist in stack (possable only not from client)
if(count > pItem->GetCount())
{
_player->SendSellError( SELL_ERR_CANT_SELL_ITEM, pCreature, itemguid, 0);
return;
}
}
ItemPrototype const *pProto = pItem->GetProto();
if( pProto )
{
if( pProto->SellPrice > 0 )
{
if(count < pItem->GetCount()) // need split items
{
Item *pNewItem = pItem->CloneItem( count, _player );
if (!pNewItem)
{
sLog.outError("WORLD: HandleSellItemOpcode - could not create clone of item %u; count = %u", pItem->GetEntry(), count );
_player->SendSellError( SELL_ERR_CANT_SELL_ITEM, pCreature, itemguid, 0);
return;
}
pItem->SetCount( pItem->GetCount() - count );
_player->ItemRemovedQuestCheck( pItem->GetEntry(), count );
if( _player->IsInWorld() )
pItem->SendCreateUpdateToPlayer( _player );
pItem->SetState(ITEM_CHANGED, _player);
_player->AddItemToBuyBackSlot( pNewItem );
if( _player->IsInWorld() )
pNewItem->SendCreateUpdateToPlayer( _player );
}
else
{
_player->ItemRemovedQuestCheck( pItem->GetEntry(), pItem->GetCount());
_player->RemoveItem( pItem->GetBagSlot(), pItem->GetSlot(), true);
pItem->RemoveFromUpdateQueueOf(_player);
_player->AddItemToBuyBackSlot( pItem );
}
_player->ModifyMoney( pProto->SellPrice * count );
}
else
_player->SendSellError( SELL_ERR_CANT_SELL_ITEM, pCreature, itemguid, 0);
return;
}
}
_player->SendSellError( SELL_ERR_CANT_FIND_ITEM, pCreature, itemguid, 0);
return;
}
//this void creates new auction and adds auction to some auctionhouse
void WorldSession::HandleAuctionSellItem(WorldPackets::AuctionHouse::AuctionSellItem& packet)
{
if (packet.Items.size() > MAX_AUCTION_ITEMS)
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
for (auto const& item : packet.Items)
if (!item.Guid || !item.UseCount || item.UseCount > 1000)
return;
if (!packet.MinBid || !packet.RunTime)
return;
if (packet.MinBid > MAX_MONEY_AMOUNT || packet.BuyoutPrice > MAX_MONEY_AMOUNT)
{
TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Player %s (%s) attempted to sell item with higher price than max gold amount.", _player->GetName().c_str(), _player->GetGUID().ToString().c_str());
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER);
if (!creature)
{
TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit (%s) not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
return;
}
AuctionHouseEntry const* auctionHouseEntry = AuctionHouseMgr::GetAuctionHouseEntry(creature->getFaction());
if (!auctionHouseEntry)
{
TC_LOG_DEBUG("network", "WORLD: HandleAuctionSellItem - Unit (%s) has wrong faction.", packet.Auctioneer.ToString().c_str());
return;
}
packet.RunTime *= MINUTE;
switch (packet.RunTime)
{
case 1 * MIN_AUCTION_TIME:
case 2 * MIN_AUCTION_TIME:
case 4 * MIN_AUCTION_TIME:
break;
default:
return;
}
if (GetPlayer()->HasUnitState(UNIT_STATE_DIED))
GetPlayer()->RemoveAurasByType(SPELL_AURA_FEIGN_DEATH);
uint32 finalCount = 0;
for (auto const& packetItem : packet.Items)
{
Item* item = _player->GetItemByGuid(packetItem.Guid);
if (!item)
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_ITEM_NOT_FOUND);
return;
}
if (sAuctionMgr->GetAItem(item->GetGUID().GetCounter()) || !item->CanBeTraded() || item->IsNotEmptyBag() ||
item->GetTemplate()->GetFlags() & ITEM_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION) ||
item->GetCount() < packetItem.UseCount)
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
finalCount += packetItem.UseCount;
}
if (packet.Items.empty())
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
if (!finalCount)
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
// check if there are 2 identical guids, in this case user is most likely cheating
for (uint32 i = 0; i < packet.Items.size() - 1; ++i)
{
for (uint32 j = i + 1; j < packet.Items.size(); ++j)
{
if (packet.Items[i].Guid == packet.Items[j].Guid)
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
}
}
for (auto const& packetItem : packet.Items)
{
Item* item = _player->GetItemByGuid(packetItem.Guid);
if (item->GetMaxStackCount() < finalCount)
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
return;
}
}
Item* item = _player->GetItemByGuid(packet.Items[0].Guid);
uint32 auctionTime = uint32(packet.RunTime * sWorld->getRate(RATE_AUCTION_TIME));
AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
uint32 deposit = sAuctionMgr->GetAuctionDeposit(auctionHouseEntry, packet.RunTime, item, finalCount);
if (!_player->HasEnoughMoney((uint64)deposit))
{
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGHT_MONEY);
return;
}
AuctionEntry* AH = new AuctionEntry();
if (sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION))
AH->auctioneer = UI64LIT(23442); ///@TODO - HARDCODED DB GUID, BAD BAD BAD
else
AH->auctioneer = packet.Auctioneer.GetCounter();
// Required stack size of auction matches to current item stack size, just move item to auctionhouse
if (packet.Items.size() == 1 && item->GetCount() == packet.Items[0].UseCount)
{
if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
{
sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
GetPlayerName().c_str(), GetAccountId(), item->GetTemplate()->GetDefaultLocaleName(), item->GetEntry(), item->GetCount());
}
AH->Id = sObjectMgr->GenerateAuctionID();
AH->itemGUIDLow = item->GetGUID().GetCounter();
AH->itemEntry = item->GetEntry();
AH->itemCount = item->GetCount();
AH->owner = _player->GetGUID().GetCounter();
AH->startbid = packet.MinBid;
AH->bidder = UI64LIT(0);
AH->bid = 0;
AH->buyout = packet.BuyoutPrice;
AH->expire_time = time(NULL) + auctionTime;
AH->deposit = deposit;
AH->auctionHouseEntry = auctionHouseEntry;
TC_LOG_INFO("network", "CMSG_AUCTION_SELL_ITEM: %s %s is selling item %s %s to auctioneer " UI64FMTD " with count %u with initial bid " UI64FMTD " with buyout " UI64FMTD " and with time %u (in sec) in auctionhouse %u",
_player->GetGUID().ToString().c_str(), _player->GetName().c_str(), item->GetGUID().ToString().c_str(), item->GetTemplate()->GetDefaultLocaleName(), AH->auctioneer, item->GetCount(), packet.MinBid, packet.BuyoutPrice, auctionTime, AH->GetHouseId());
sAuctionMgr->AddAItem(item);
auctionHouse->AddAuction(AH);
_player->MoveItemFromInventory(item->GetBagSlot(), item->GetSlot(), true);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
item->DeleteFromInventoryDB(trans);
item->SaveToDB(trans);
AH->SaveToDB(trans);
_player->SaveInventoryAndGoldToDB(trans);
CharacterDatabase.CommitTransaction(trans);
SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_OK);
GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
}
else // Required stack size of auction does not match to current item stack size, clone item and set correct stack size
{
Item* newItem = item->CloneItem(finalCount, _player);
if (!newItem)
{
TC_LOG_ERROR("network", "CMSG_AUCTION_SELL_ITEM: Could not create clone of item %u", item->GetEntry());
SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_DATABASE_ERROR);
delete AH;
return;
}
if (HasPermission(rbac::RBAC_PERM_LOG_GM_TRADE))
{
sLog->outCommand(GetAccountId(), "GM %s (Account: %u) create auction: %s (Entry: %u Count: %u)",
GetPlayerName().c_str(), GetAccountId(), newItem->GetTemplate()->GetDefaultLocaleName(), newItem->GetEntry(), newItem->GetCount());
}
AH->Id = sObjectMgr->GenerateAuctionID();
AH->itemGUIDLow = newItem->GetGUID().GetCounter();
AH->itemEntry = newItem->GetEntry();
AH->itemCount = newItem->GetCount();
AH->owner = _player->GetGUID().GetCounter();
AH->startbid = packet.MinBid;
AH->bidder = UI64LIT(0);
AH->bid = 0;
AH->buyout = packet.BuyoutPrice;
AH->expire_time = time(NULL) + auctionTime;
AH->deposit = deposit;
AH->auctionHouseEntry = auctionHouseEntry;
TC_LOG_INFO("network", "CMSG_AUCTION_SELL_ITEM: %s %s is selling %s %s to auctioneer " UI64FMTD " with count %u with initial bid " UI64FMTD " with buyout " UI64FMTD " and with time %u (in sec) in auctionhouse %u",
_player->GetGUID().ToString().c_str(), _player->GetName().c_str(), newItem->GetGUID().ToString().c_str(), newItem->GetTemplate()->GetDefaultLocaleName(), AH->auctioneer, newItem->GetCount(), packet.MinBid, packet.BuyoutPrice, auctionTime, AH->GetHouseId());
sAuctionMgr->AddAItem(newItem);
auctionHouse->AddAuction(AH);
for (auto const& packetItem : packet.Items)
{
Item* item2 = _player->GetItemByGuid(packetItem.Guid);
// Item stack count equals required count, ready to delete item - cloned item will be used for auction
if (item2->GetCount() == packetItem.UseCount)
{
_player->MoveItemFromInventory(item2->GetBagSlot(), item2->GetSlot(), true);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
item2->DeleteFromInventoryDB(trans);
item2->DeleteFromDB(trans);
CharacterDatabase.CommitTransaction(trans);
delete item2;
}
else // Item stack count is bigger than required count, update item stack count and save to database - cloned item will be used for auction
{
item2->SetCount(item2->GetCount() - packetItem.UseCount);
item2->SetState(ITEM_CHANGED, _player);
_player->ItemRemovedQuestCheck(item2->GetEntry(), packetItem.UseCount);
item2->SendUpdateToPlayer(_player);
SQLTransaction trans = CharacterDatabase.BeginTransaction();
item2->SaveToDB(trans);
CharacterDatabase.CommitTransaction(trans);
}
}
SQLTransaction trans = CharacterDatabase.BeginTransaction();
newItem->SaveToDB(trans);
AH->SaveToDB(trans);
_player->SaveInventoryAndGoldToDB(trans);
CharacterDatabase.CommitTransaction(trans);
SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_OK);
GetPlayer()->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CREATE_AUCTION, 1);
}
_player->ModifyMoney(-int32(deposit));
}