*Backed out changeset 3be01fb200a5

--HG--
branch : trunk

1 files changed, 44 insertions, 0 deletions

diff --git a/src/game/SkillDiscovery.cpp b/src/game/SkillDiscovery.cpp
index d30d25e2355..b1e16897b18 100644
--- a/src/game/SkillDiscovery.cpp
+++ b/src/game/SkillDiscovery.cpp
@@ -17,6 +17,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
+
 #include "Database/DatabaseEnv.h"
 #include "Log.h"
 #include "ProgressBar.h"
@@ -27,48 +28,64 @@
 #include "SpellMgr.h"
 #include "Player.h"
 #include <map>
+
 struct SkillDiscoveryEntry
 {
     uint32  spellId;                                        // discavered spell
     uint32  reqSkillValue;                                  // skill level limitation
     float   chance;                                         // chance
+
     SkillDiscoveryEntry()
         : spellId(0), reqSkillValue(0), chance(0) {}
+
     SkillDiscoveryEntry(uint32 _spellId, uint32 req_skill_val, float _chance)
         : spellId(_spellId), reqSkillValue(req_skill_val), chance(_chance) {}
 };
+
 typedef std::list<SkillDiscoveryEntry> SkillDiscoveryList;
 typedef UNORDERED_MAP<int32, SkillDiscoveryList> SkillDiscoveryMap;
+
 static SkillDiscoveryMap SkillDiscoveryStore;
+
 void LoadSkillDiscoveryTable()
 {
+
     SkillDiscoveryStore.clear();                            // need for reload
+
     uint32 count = 0;
+
     //                                                0        1         2              3
     QueryResult *result = WorldDatabase.Query("SELECT spellId, reqSpell, reqSkillValue, chance FROM skill_discovery_template");
+
     if (!result)
     {
         sLog.outString();
         sLog.outString( ">> Loaded 0 skill discovery definitions. DB table `skill_discovery_template` is empty." );
         return;
     }
+
     barGoLink bar(result->GetRowCount());
+
     std::ostringstream ssNonDiscoverableEntries;
     std::set<uint32> reportedReqSpells;
+
     do
     {
         Field *fields = result->Fetch();
         bar.step();
+
         uint32 spellId         = fields[0].GetUInt32();
         int32  reqSkillOrSpell = fields[1].GetInt32();
         uint32 reqSkillValue   = fields[2].GetInt32();
         float  chance          = fields[3].GetFloat();
+
         if (chance <= 0)                                    // chance
         {
             ssNonDiscoverableEntries << "spellId = " << spellId << " reqSkillOrSpell = " << reqSkillOrSpell
                 << " reqSkillValue = " << reqSkillValue << " chance = " << chance << "(chance problem)\n";
             continue;
         }
+
         if (reqSkillOrSpell > 0)                            // spell case
         {
             SpellEntry const* reqSpellEntry = sSpellStore.LookupEntry(reqSkillOrSpell);
@@ -81,6 +98,7 @@ void LoadSkillDiscoveryTable()
                 }
                 continue;
             }
+
             // mechanic discovery
             if (reqSpellEntry->Mechanic != MECHANIC_DISCOVERY &&
                 // explicit discovery ability
@@ -95,16 +113,19 @@ void LoadSkillDiscoveryTable()
                 }
                 continue;
             }
+
             SkillDiscoveryStore[reqSkillOrSpell].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
         }
         else if (reqSkillOrSpell == 0)                      // skill case
         {
             SkillLineAbilityMapBounds bounds = spellmgr.GetSkillLineAbilityMapBounds(spellId);
+
             if (bounds.first==bounds.second)
             {
                 sLog.outErrorDb("Spell (ID: %u) not listed in `SkillLineAbility.dbc` but listed with `reqSpell`=0 in `skill_discovery_template` table",spellId);
                 continue;
             }
+
             for(SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
                 SkillDiscoveryStore[-int32(_spell_idx->second->skillId)].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
         }
@@ -113,26 +134,33 @@ void LoadSkillDiscoveryTable()
             sLog.outErrorDb("Spell (ID: %u) have negative value in `reqSpell` field in `skill_discovery_template` table",spellId);
             continue;
         }
+
         ++count;
     } while (result->NextRow());
+
     delete result;
+
     sLog.outString();
     sLog.outString( ">> Loaded %u skill discovery definitions", count );
     if (!ssNonDiscoverableEntries.str().empty())
         sLog.outErrorDb("Some items can't be successfully discovered: have in chance field value < 0.000001 in `skill_discovery_template` DB table . List:\n%s",ssNonDiscoverableEntries.str().c_str());
+
     // report about empty data for explicit discovery spells
     for(uint32 spell_id = 1; spell_id < sSpellStore.GetNumRows(); ++spell_id)
     {
         SpellEntry const* spellEntry = sSpellStore.LookupEntry(spell_id);
         if (!spellEntry)
             continue;
+
         // skip not explicit discovery spells
         if (!IsExplicitDiscoverySpell(spellEntry))
             continue;
+
         if (SkillDiscoveryStore.find(spell_id)==SkillDiscoveryStore.end())
             sLog.outErrorDb("Spell (ID: %u) is 100%% chance random discovery ability but not have data in `skill_discovery_template` table",spell_id);
     }
 }
+
 uint32 GetExplicitDiscoverySpell(uint32 spellId, Player* player)
 {
     // explicit discovery spell chances (always success if case exist)
@@ -140,32 +168,43 @@ uint32 GetExplicitDiscoverySpell(uint32 spellId, Player* player)
     SkillDiscoveryMap::const_iterator tab = SkillDiscoveryStore.find(spellId);
     if (tab == SkillDiscoveryStore.end())
         return 0;
+
     SkillLineAbilityMapBounds bounds = spellmgr.GetSkillLineAbilityMapBounds(spellId);
     uint32 skillvalue = bounds.first != bounds.second ? player->GetSkillValue(bounds.first->second->skillId) : 0;
+
     float full_chance = 0;
     for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
         if (item_iter->reqSkillValue <= skillvalue)
             if (!player->HasSpell(item_iter->spellId))
                 full_chance += item_iter->chance;
+
     float rate = full_chance / 100.0f;
     float roll = rand_chance() * rate;                      // roll now in range 0..full_chance
+
     for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
     {
         if (item_iter->reqSkillValue > skillvalue)
             continue;
+
         if (player->HasSpell(item_iter->spellId))
             continue;
+
         if (item_iter->chance > roll)
             return item_iter->spellId;
+
         roll -= item_iter->chance;
     }
+
     return 0;
 }
+
 uint32 GetSkillDiscoverySpell(uint32 skillId, uint32 spellId, Player* player)
 {
     uint32 skillvalue = skillId ? player->GetSkillValue(skillId) : 0;
+
     // check spell case
     SkillDiscoveryMap::const_iterator tab = SkillDiscoveryStore.find(spellId);
+
     if (tab != SkillDiscoveryStore.end())
     {
         for(SkillDiscoveryList::const_iterator item_iter = tab->second.begin(); item_iter != tab->second.end(); ++item_iter)
@@ -175,10 +214,13 @@ uint32 GetSkillDiscoverySpell(uint32 skillId, uint32 spellId, Player* player)
                 !player->HasSpell(item_iter->spellId))
                 return item_iter->spellId;
         }
+
         return 0;
     }
+
     if (!skillId)
         return 0;
+
     // check skill line case
     tab = SkillDiscoveryStore.find(-(int32)skillId);
     if (tab != SkillDiscoveryStore.end())
@@ -190,8 +232,10 @@ uint32 GetSkillDiscoverySpell(uint32 skillId, uint32 spellId, Player* player)
                 !player->HasSpell(item_iter->spellId))
                 return item_iter->spellId;
         }
+
         return 0;
     }
+
     return 0;
 }