[7248] Check battlemaster_entry data at loading. Code cleanups. Author: zhenya

--HG--
branch : trunk

src/game/AuctionHouse.cpp

@@ -582,7 +582,7 @@ void WorldSession::HandleAuctionListBidderItems( WorldPacket & recv_data )
             ++count;
         }
     }
-    for (AuctionHouseObject::AuctionEntryMap::iterator itr = mAuctions->GetAuctionsBegin();itr != mAuctions->GetAuctionsEnd();++itr)
+    for (AuctionHouseObject::AuctionEntryMap::const_iterator itr = mAuctions->GetAuctionsBegin();itr != mAuctions->GetAuctionsEnd();++itr)
     {
         AuctionEntry *Aentry = itr->second;
         if( Aentry && Aentry->bidder == pl->GetGUIDLow() )
@@ -629,7 +629,7 @@ void WorldSession::HandleAuctionListOwnerItems( WorldPacket & recv_data )
 
     uint32 count = 0;
     uint32 totalcount = 0;
-    for (AuctionHouseObject::AuctionEntryMap::iterator itr = mAuctions->GetAuctionsBegin();itr != mAuctions->GetAuctionsEnd();++itr)
+    for (AuctionHouseObject::AuctionEntryMap::const_iterator itr = mAuctions->GetAuctionsBegin();itr != mAuctions->GetAuctionsEnd();++itr)
     {
         AuctionEntry *Aentry = itr->second;
         if( Aentry && Aentry->owner == _player->GetGUIDLow() )
@@ -695,7 +695,7 @@ void WorldSession::HandleAuctionListItems( WorldPacket & recv_data )
 
     wstrToLower(wsearchedname);
 
-    for (AuctionHouseObject::AuctionEntryMap::iterator itr = mAuctions->GetAuctionsBegin();itr != mAuctions->GetAuctionsEnd();++itr)
+    for (AuctionHouseObject::AuctionEntryMap::const_iterator itr = mAuctions->GetAuctionsBegin();itr != mAuctions->GetAuctionsEnd();++itr)
     {
         AuctionEntry *Aentry = itr->second;
         Item *item = objmgr.GetAItem(Aentry->item_guidlow);

src/game/BattleGround.h

@@ -146,6 +146,7 @@ enum BattleGroundTypeId
     BATTLEGROUND_DS            = 10,
     BATTLEGROUND_RV            = 11
 };
+#define MAX_BATTLEGROUND_TYPE_ID 12
 
 // handle the queue types and bg types separately to enable joining queue for different sized arenas at the same time
 enum BattleGroundQueueTypeId

src/game/Creature.h

@@ -369,14 +369,14 @@ typedef std::list<VendorItemCount> VendorItemCounts;
 struct TrainerSpell
 {
     uint32 spell;
-    uint32 spellcost;
+    uint32 spellCost;
-    uint32 reqskill;
+    uint32 reqSkill;
-    uint32 reqskillvalue;
+    uint32 reqSkillValue;
-    uint32 reqlevel;
+    uint32 reqLevel;
-    uint32 learned_spell;
+    uint32 learnedSpell;
 
     // helpers
-    bool IsCastable() const { return learned_spell != spell; }
+    bool IsCastable() const { return learnedSpell != spell; }
 };
 
 typedef std::vector<TrainerSpell*> TrainerSpellList;

src/game/ItemHandler.cpp

@@ -742,7 +742,7 @@ void WorldSession::SendListInventory( uint64 vendorguid )
 
     float discountMod = _player->GetReputationPriceDiscount(pCreature);
 
-    for(int i = 0; i < numitems; i++ )
+    for(int i = 0; i < numitems; ++i )
     {
         if(VendorItem const* crItem = vItems->GetItem(i))
         {

src/game/NPCHandler.cpp

@@ -166,25 +166,25 @@ void WorldSession::SendTrainerList( uint64 guid, const std::string& strTitle )
     {
         TrainerSpell const* tSpell = *itr;
 
-        if(!_player->IsSpellFitByClassAndRace(tSpell->learned_spell))
+        if(!_player->IsSpellFitByClassAndRace(tSpell->learnedSpell))
             continue;
 
         ++count;
 
-        bool primary_prof_first_rank = spellmgr.IsPrimaryProfessionFirstRankSpell(tSpell->learned_spell);
+        bool primary_prof_first_rank = spellmgr.IsPrimaryProfessionFirstRankSpell(tSpell->learnedSpell);
 
-        SpellChainNode const* chain_node = spellmgr.GetSpellChainNode(tSpell->learned_spell);
+        SpellChainNode const* chain_node = spellmgr.GetSpellChainNode(tSpell->learnedSpell);
         uint32 req_spell = spellmgr.GetSpellRequired(tSpell->spell);
 
         data << uint32(tSpell->spell);                      // learned spell (or cast-spell in profession case)
         data << uint8(_player->GetTrainerSpellState(tSpell));
-        data << uint32(floor(tSpell->spellcost * fDiscountMod));
+        data << uint32(floor(tSpell->spellCost * fDiscountMod));
 
         data << uint32(primary_prof_first_rank ? 1 : 0);    // primary prof. learn confirmation dialog
         data << uint32(primary_prof_first_rank ? 1 : 0);    // must be equal prev. field to have learn button in enabled state
-        data << uint8(tSpell->reqlevel);
+        data << uint8(tSpell->reqLevel);
-        data << uint32(tSpell->reqskill);
+        data << uint32(tSpell->reqSkill);
-        data << uint32(tSpell->reqskillvalue);
+        data << uint32(tSpell->reqSkillValue);
         data << uint32(chain_node && chain_node->prev ? chain_node->prev : req_spell);
         data << uint32(chain_node && chain_node->prev ? req_spell : 0);
         data << uint32(0);
@@ -235,7 +235,7 @@ void WorldSession::HandleTrainerBuySpellOpcode( WorldPacket & recv_data )
         return;
 
     // apply reputation discount
-    uint32 nSpellCost = uint32(floor(trainer_spell->spellcost * _player->GetReputationPriceDiscount(unit)));
+    uint32 nSpellCost = uint32(floor(trainer_spell->spellCost * _player->GetReputationPriceDiscount(unit)));
 
     // check money requirement
     if(_player->GetMoney() < nSpellCost )

src/game/ObjectMgr.cpp

@@ -46,6 +46,7 @@
 #include "Util.h"
 #include "WaypointManager.h"
 #include "InstanceData.h" //for condition_instance_data
+#include "BattleGround.h"
 
 INSTANTIATE_SINGLETON_1(ObjectMgr);
 
@@ -6749,6 +6750,11 @@ void ObjectMgr::LoadBattleMastersEntry()
 
         uint32 entry = fields[0].GetUInt32();
         uint32 bgTypeId  = fields[1].GetUInt32();
+        if (bgTypeId >= MAX_BATTLEGROUND_TYPE_ID)
+        {
+            sLog.outErrorDb("Table `battlemaster_entry` contain entry %u for not existed battleground type %u, ignored.",entry,bgTypeId);
+            continue;
+        }
 
         mBattleMastersMap[entry] = bgTypeId;
 
@@ -7501,16 +7507,16 @@ void ObjectMgr::LoadTrainerSpell()
 
         TrainerSpell* pTrainerSpell = new TrainerSpell();
         pTrainerSpell->spell         = spell;
-        pTrainerSpell->spellcost     = fields[2].GetUInt32();
+        pTrainerSpell->spellCost     = fields[2].GetUInt32();
-        pTrainerSpell->reqskill      = fields[3].GetUInt32();
+        pTrainerSpell->reqSkill      = fields[3].GetUInt32();
-        pTrainerSpell->reqskillvalue = fields[4].GetUInt32();
+        pTrainerSpell->reqSkillValue = fields[4].GetUInt32();
-        pTrainerSpell->reqlevel      = fields[5].GetUInt32();
+        pTrainerSpell->reqLevel      = fields[5].GetUInt32();
 
-        if(!pTrainerSpell->reqlevel)
+        if(!pTrainerSpell->reqLevel)
-            pTrainerSpell->reqlevel = spellinfo->spellLevel;
+            pTrainerSpell->reqLevel = spellinfo->spellLevel;
 
         // calculate learned spell for profession case when stored cast-spell
-        pTrainerSpell->learned_spell = spell;
+        pTrainerSpell->learnedSpell = spell;
         for(int i = 0; i <3; ++i)
         {
             if(spellinfo->Effect[i]!=SPELL_EFFECT_LEARN_SPELL)
@@ -7518,7 +7524,7 @@ void ObjectMgr::LoadTrainerSpell()
 
             if(SpellMgr::IsProfessionOrRidingSpell(spellinfo->EffectTriggerSpell[i]))
             {
-                pTrainerSpell->learned_spell = spellinfo->EffectTriggerSpell[i];
+                pTrainerSpell->learnedSpell = spellinfo->EffectTriggerSpell[i];
                 break;
             }
         }

src/game/Player.cpp

@@ -3674,22 +3674,22 @@ TrainerSpellState Player::GetTrainerSpellState(TrainerSpell const* trainer_spell
     if (!trainer_spell)
         return TRAINER_SPELL_RED;
 
-    if (!trainer_spell->learned_spell)
+    if (!trainer_spell->learnedSpell)
         return TRAINER_SPELL_RED;
 
     // known spell
-    if(HasSpell(trainer_spell->learned_spell))
+    if(HasSpell(trainer_spell->learnedSpell))
         return TRAINER_SPELL_GRAY;
 
     // check race/class requirement
-    if(!IsSpellFitByClassAndRace(trainer_spell->learned_spell))
+    if(!IsSpellFitByClassAndRace(trainer_spell->learnedSpell))
         return TRAINER_SPELL_RED;
 
     // check level requirement
-    if(getLevel() < trainer_spell->reqlevel)
+    if(getLevel() < trainer_spell->reqLevel)
         return TRAINER_SPELL_RED;
 
-    if(SpellChainNode const* spell_chain = spellmgr.GetSpellChainNode(trainer_spell->learned_spell))
+    if(SpellChainNode const* spell_chain = spellmgr.GetSpellChainNode(trainer_spell->learnedSpell))
     {
         // check prev.rank requirement
         if(spell_chain->prev && !HasSpell(spell_chain->prev))
@@ -3704,11 +3704,11 @@ TrainerSpellState Player::GetTrainerSpellState(TrainerSpell const* trainer_spell
     }
 
     // check skill requirement
-    if(trainer_spell->reqskill && GetBaseSkillValue(trainer_spell->reqskill) < trainer_spell->reqskillvalue)
+    if(trainer_spell->reqSkill && GetBaseSkillValue(trainer_spell->reqSkill) < trainer_spell->reqSkillValue)
         return TRAINER_SPELL_RED;
 
     // exist, already checked at loading
-    SpellEntry const* spell = sSpellStore.LookupEntry(trainer_spell->learned_spell);
+    SpellEntry const* spell = sSpellStore.LookupEntry(trainer_spell->learnedSpell);
 
     // secondary prof. or not prof. spell
     uint32 skill = spell->EffectMiscValue[1];

src/shared/revision_nr.h

@@ -1,4 +1,4 @@
 #ifndef __REVISION_NR_H__
 #define __REVISION_NR_H__
- #define REVISION_NR "7246"
+ #define REVISION_NR "7248"
 #endif // __REVISION_NR_H__