hondacrx
1096 lines
44 KiB
C#
1096 lines
44 KiB
C#
/*
|
|
* Copyright (C) 2012-2018 CypherCore <http://github.com/CypherCore>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
using Framework.Constants;
|
|
using Framework.Database;
|
|
using Game.Conditions;
|
|
using Game.DataStorage;
|
|
using Game.Entities;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Game.Loots
|
|
{
|
|
using LootStoreItemList = List<LootStoreItem>;
|
|
using LootTemplateMap = Dictionary<uint, LootTemplate>;
|
|
|
|
public class LootManager : LootStorage
|
|
{
|
|
static void Initialize()
|
|
{
|
|
Creature = new LootStore("creature_loot_template", "creature entry");
|
|
Disenchant = new LootStore("disenchant_loot_template", "item disenchant id");
|
|
Fishing = new LootStore("fishing_loot_template", "area id");
|
|
Gameobject = new LootStore("gameobject_loot_template", "gameobject entry");
|
|
Items = new LootStore("item_loot_template", "item entry");
|
|
Mail = new LootStore("mail_loot_template", "mail template id", false);
|
|
Milling = new LootStore("milling_loot_template", "item entry (herb)");
|
|
Pickpocketing = new LootStore("pickpocketing_loot_template", "creature pickpocket lootid");
|
|
Prospecting = new LootStore("prospecting_loot_template", "item entry (ore)");
|
|
Reference = new LootStore("reference_loot_template", "reference id", false);
|
|
Skinning = new LootStore("skinning_loot_template", "creature skinning id");
|
|
Spell = new LootStore("spell_loot_template", "spell id (random item creating)", false);
|
|
}
|
|
|
|
public static void LoadLootTables()
|
|
{
|
|
Initialize();
|
|
LoadLootTemplates_Creature();
|
|
LoadLootTemplates_Fishing();
|
|
LoadLootTemplates_Gameobject();
|
|
LoadLootTemplates_Item();
|
|
LoadLootTemplates_Mail();
|
|
LoadLootTemplates_Milling();
|
|
LoadLootTemplates_Pickpocketing();
|
|
LoadLootTemplates_Skinning();
|
|
LoadLootTemplates_Disenchant();
|
|
LoadLootTemplates_Prospecting();
|
|
LoadLootTemplates_Spell();
|
|
|
|
LoadLootTemplates_Reference();
|
|
}
|
|
|
|
public static void LoadLootTemplates_Creature()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading creature loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet, lootIdSetUsed = new List<uint>();
|
|
uint count = Creature.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// Remove real entries and check loot existence
|
|
var ctc = Global.ObjectMgr.GetCreatureTemplates();
|
|
foreach (var pair in ctc)
|
|
{
|
|
uint lootid = pair.Value.LootId;
|
|
if (lootid != 0)
|
|
{
|
|
if (!lootIdSet.Contains(lootid))
|
|
Creature.ReportNonExistingId(lootid, pair.Value.Entry);
|
|
else
|
|
lootIdSetUsed.Add(lootid);
|
|
}
|
|
}
|
|
|
|
foreach (var id in lootIdSetUsed)
|
|
lootIdSet.Remove(id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Creature.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} creature loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 creature loot templates. DB table `creature_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Disenchant()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading disenchanting loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet, lootIdSetUsed = new List<uint>();
|
|
uint count = Disenchant.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
foreach (var disenchant in CliDB.ItemDisenchantLootStorage.Values)
|
|
{
|
|
uint lootid = disenchant.Id;
|
|
if (!lootIdSet.Contains(lootid))
|
|
Disenchant.ReportNonExistingId(lootid, disenchant.Id);
|
|
else
|
|
lootIdSetUsed.Add(lootid);
|
|
}
|
|
|
|
foreach (var id in lootIdSetUsed)
|
|
lootIdSet.Remove(id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Disenchant.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} disenchanting loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 disenchanting loot templates. DB table `disenchant_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Fishing()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading fishing loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
uint count = Fishing.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
foreach (var areaEntry in CliDB.AreaTableStorage.Values)
|
|
if (lootIdSet.Contains(areaEntry.Id))
|
|
lootIdSet.Remove(areaEntry.Id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Fishing.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} fishing loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 fishing loot templates. DB table `fishing_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Gameobject()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading gameobject loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet, lootIdSetUsed = new List<uint>();
|
|
uint count = Gameobject.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
var gotc = Global.ObjectMgr.GetGameObjectTemplates();
|
|
foreach (var go in gotc)
|
|
{
|
|
uint lootid = go.Value.GetLootId();
|
|
if (lootid != 0)
|
|
{
|
|
if (!lootIdSet.Contains(lootid))
|
|
Gameobject.ReportNonExistingId(lootid, go.Value.entry);
|
|
else
|
|
lootIdSetUsed.Add(lootid);
|
|
}
|
|
}
|
|
|
|
foreach (var id in lootIdSetUsed)
|
|
lootIdSet.Remove(id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Gameobject.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} gameobject loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 gameobject loot templates. DB table `gameobject_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Item()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading item loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
uint count = Items.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
var its = Global.ObjectMgr.GetItemTemplates();
|
|
foreach (var pair in its)
|
|
if (lootIdSet.Contains(pair.Value.GetId()) && pair.Value.GetFlags().HasAnyFlag(ItemFlags.HasLoot))
|
|
lootIdSet.Remove(pair.Value.GetId());
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Items.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} item loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 item loot templates. DB table `item_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Milling()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading milling loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
uint count = Milling.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
var its = Global.ObjectMgr.GetItemTemplates();
|
|
foreach (var pair in its)
|
|
{
|
|
if (!pair.Value.GetFlags().HasAnyFlag(ItemFlags.IsMillable))
|
|
continue;
|
|
|
|
if (lootIdSet.Contains(pair.Value.GetId()))
|
|
lootIdSet.Remove(pair.Value.GetId());
|
|
}
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Milling.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} milling loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 milling loot templates. DB table `milling_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Pickpocketing()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading pickpocketing loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
List<uint> lootIdSetUsed = new List<uint>();
|
|
uint count = Pickpocketing.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// Remove real entries and check loot existence
|
|
var ctc = Global.ObjectMgr.GetCreatureTemplates();
|
|
foreach (var pair in ctc)
|
|
{
|
|
uint lootid = pair.Value.PickPocketId;
|
|
if (lootid != 0)
|
|
{
|
|
if (!lootIdSet.Contains(lootid))
|
|
Pickpocketing.ReportNonExistingId(lootid, pair.Value.Entry);
|
|
else
|
|
lootIdSetUsed.Add(lootid);
|
|
}
|
|
}
|
|
|
|
foreach (var id in lootIdSetUsed)
|
|
lootIdSet.Remove(id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Pickpocketing.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} pickpocketing loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 pickpocketing loot templates. DB table `pickpocketing_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Prospecting()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading prospecting loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
uint count = Prospecting.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
var its = Global.ObjectMgr.GetItemTemplates();
|
|
foreach (var pair in its)
|
|
{
|
|
if (!pair.Value.GetFlags().HasAnyFlag(ItemFlags.IsProspectable))
|
|
continue;
|
|
|
|
if (lootIdSet.Contains(pair.Value.GetId()))
|
|
lootIdSet.Remove(pair.Value.GetId());
|
|
}
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Prospecting.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} prospecting loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 prospecting loot templates. DB table `prospecting_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Mail()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading mail loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
uint count = Mail.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
foreach (var mail in CliDB.MailTemplateStorage.Values)
|
|
if (lootIdSet.Contains(mail.Id))
|
|
lootIdSet.Remove(mail.Id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Mail.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} mail loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 mail loot templates. DB table `mail_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Skinning()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading skinning loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
List<uint> lootIdSetUsed = new List<uint>();
|
|
uint count = Skinning.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
var ctc = Global.ObjectMgr.GetCreatureTemplates();
|
|
foreach (var pair in ctc)
|
|
{
|
|
uint lootid = pair.Value.SkinLootId;
|
|
if (lootid != 0)
|
|
{
|
|
if (!lootIdSet.Contains(lootid))
|
|
Skinning.ReportNonExistingId(lootid, pair.Value.Entry);
|
|
else
|
|
lootIdSetUsed.Add(lootid);
|
|
}
|
|
}
|
|
|
|
foreach (var id in lootIdSetUsed)
|
|
lootIdSet.Remove(id);
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Skinning.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} skinning loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 skinning loot templates. DB table `skinning_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Spell()
|
|
{
|
|
// TODO: change this to use MiscValue from spell effect as id instead of spell id
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading spell loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
uint count = Spell.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// remove real entries and check existence loot
|
|
foreach (var spellInfo in Global.SpellMgr.GetSpellInfoStorage().Values)
|
|
{
|
|
// possible cases
|
|
if (!spellInfo.IsLootCrafting())
|
|
continue;
|
|
|
|
if (!lootIdSet.Contains(spellInfo.Id))
|
|
{
|
|
// not report about not trainable spells (optionally supported by DB)
|
|
// ignore 61756 (Northrend Inscription Research (FAST QA VERSION) for example
|
|
if (!spellInfo.HasAttribute(SpellAttr0.NotShapeshift) || spellInfo.HasAttribute(SpellAttr0.Tradespell))
|
|
{
|
|
Spell.ReportNonExistingId(spellInfo.Id, spellInfo.Id);
|
|
}
|
|
}
|
|
else
|
|
lootIdSet.Remove(spellInfo.Id);
|
|
}
|
|
|
|
// output error for any still listed (not referenced from appropriate table) ids
|
|
Spell.ReportUnusedIds(lootIdSet);
|
|
|
|
if (count != 0)
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded {0} spell loot templates in {1} ms", count, Time.GetMSTimeDiffToNow(oldMSTime));
|
|
else
|
|
Log.outError(LogFilter.ServerLoading, "Loaded 0 spell loot templates. DB table `spell_loot_template` is empty");
|
|
}
|
|
|
|
public static void LoadLootTemplates_Reference()
|
|
{
|
|
Log.outInfo(LogFilter.ServerLoading, "Loading reference loot templates...");
|
|
|
|
uint oldMSTime = Time.GetMSTime();
|
|
|
|
List<uint> lootIdSet;
|
|
Reference.LoadAndCollectLootIds(out lootIdSet);
|
|
|
|
// check references and remove used
|
|
Creature.CheckLootRefs(lootIdSet);
|
|
Fishing.CheckLootRefs(lootIdSet);
|
|
Gameobject.CheckLootRefs(lootIdSet);
|
|
Items.CheckLootRefs(lootIdSet);
|
|
Milling.CheckLootRefs(lootIdSet);
|
|
Pickpocketing.CheckLootRefs(lootIdSet);
|
|
Skinning.CheckLootRefs(lootIdSet);
|
|
Disenchant.CheckLootRefs(lootIdSet);
|
|
Prospecting.CheckLootRefs(lootIdSet);
|
|
Mail.CheckLootRefs(lootIdSet);
|
|
Reference.CheckLootRefs(lootIdSet);
|
|
|
|
// output error for any still listed ids (not referenced from any loot table)
|
|
Reference.ReportUnusedIds(lootIdSet);
|
|
|
|
Log.outInfo(LogFilter.ServerLoading, "Loaded refence loot templates in {0} ms", Time.GetMSTimeDiffToNow(oldMSTime));
|
|
}
|
|
}
|
|
|
|
public class LootStoreItem
|
|
{
|
|
public uint itemid; // id of the item
|
|
public uint reference; // referenced TemplateleId
|
|
public float chance; // chance to drop for both quest and non-quest items, chance to be used for refs
|
|
public ushort lootmode;
|
|
public bool needs_quest; // quest drop (negative ChanceOrQuestChance in DB)
|
|
public byte groupid;
|
|
public byte mincount; // mincount for drop items
|
|
public byte maxcount; // max drop count for the item mincount or Ref multiplicator
|
|
public List<Condition> conditions; // additional loot condition
|
|
|
|
public LootStoreItem(uint _itemid, uint _reference, float _chance, bool _needs_quest, ushort _lootmode, byte _groupid, byte _mincount, byte _maxcount)
|
|
{
|
|
itemid = _itemid;
|
|
reference = _reference;
|
|
chance = _chance;
|
|
lootmode = _lootmode;
|
|
needs_quest = _needs_quest;
|
|
groupid = _groupid;
|
|
mincount = _mincount;
|
|
maxcount = _maxcount;
|
|
conditions = new List<Condition>();
|
|
}
|
|
|
|
public bool Roll(bool rate)
|
|
{
|
|
if (chance >= 100.0f)
|
|
return true;
|
|
|
|
if (reference > 0) // reference case
|
|
return RandomHelper.randChance(chance * (rate ? WorldConfig.GetFloatValue(WorldCfg.RateDropItemReferenced) : 1.0f));
|
|
|
|
ItemTemplate pProto = Global.ObjectMgr.GetItemTemplate(itemid);
|
|
|
|
float qualityModifier = pProto != null && rate ? WorldConfig.GetFloatValue(qualityToRate[(int)pProto.GetQuality()]) : 1.0f;
|
|
|
|
return RandomHelper.randChance(chance * qualityModifier);
|
|
}
|
|
public bool IsValid(LootStore store, uint entry)
|
|
{
|
|
if (mincount == 0)
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: wrong mincount ({3}) - skipped", store.GetName(), entry, itemid, reference);
|
|
return false;
|
|
}
|
|
|
|
if (reference == 0) // item (quest or non-quest) entry, maybe grouped
|
|
{
|
|
ItemTemplate proto = Global.ObjectMgr.GetItemTemplate(itemid);
|
|
if (proto == null)
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: item entry not listed in `item_template` - skipped", store.GetName(), entry, itemid);
|
|
return false;
|
|
}
|
|
|
|
if (chance == 0 && groupid == 0) // Zero chance is allowed for grouped entries only
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: equal-chanced grouped entry, but group not defined - skipped", store.GetName(), entry, itemid);
|
|
return false;
|
|
}
|
|
|
|
if (chance != 0 && chance < 0.000001f) // loot with low chance
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: low chance ({3}) - skipped",
|
|
store.GetName(), entry, itemid, chance);
|
|
return false;
|
|
}
|
|
|
|
if (maxcount < mincount) // wrong max count
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: max count ({3}) less that min count ({4}) - skipped", store.GetName(), entry, itemid, maxcount, reference);
|
|
return false;
|
|
}
|
|
}
|
|
else // mincountOrRef < 0
|
|
{
|
|
if (needs_quest)
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: quest chance will be treated as non-quest chance", store.GetName(), entry, itemid);
|
|
else if (chance == 0) // no chance for the reference
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: zero chance is specified for a reference, skipped", store.GetName(), entry, itemid);
|
|
return false;
|
|
}
|
|
}
|
|
return true; // Referenced template existence is checked at whole store level
|
|
}
|
|
|
|
public static WorldCfg[] qualityToRate = new WorldCfg[7]
|
|
{
|
|
WorldCfg.RateDropItemPoor, // ITEM_QUALITY_POOR
|
|
WorldCfg.RateDropItemNormal, // ITEM_QUALITY_NORMAL
|
|
WorldCfg.RateDropItemUncommon, // ITEM_QUALITY_UNCOMMON
|
|
WorldCfg.RateDropItemRare, // ITEM_QUALITY_RARE
|
|
WorldCfg.RateDropItemEpic, // ITEM_QUALITY_EPIC
|
|
WorldCfg.RateDropItemLegendary, // ITEM_QUALITY_LEGENDARY
|
|
WorldCfg.RateDropItemArtifact, // ITEM_QUALITY_ARTIFACT
|
|
};
|
|
}
|
|
|
|
public class LootStore
|
|
{
|
|
public LootStore(string name, string entryName, bool ratesAllowed = true)
|
|
{
|
|
m_name = name;
|
|
m_entryName = entryName;
|
|
m_ratesAllowed = ratesAllowed;
|
|
}
|
|
|
|
void Verify()
|
|
{
|
|
foreach (var i in m_LootTemplates)
|
|
i.Value.Verify(this, i.Key);
|
|
}
|
|
|
|
public uint LoadAndCollectLootIds(out List<uint> lootIdSet)
|
|
{
|
|
uint count = LoadLootTable();
|
|
lootIdSet = new List<uint>();
|
|
|
|
foreach (var tab in m_LootTemplates)
|
|
lootIdSet.Add(tab.Key);
|
|
|
|
return count;
|
|
}
|
|
public void CheckLootRefs(List<uint> ref_set = null)
|
|
{
|
|
foreach (var pair in m_LootTemplates)
|
|
pair.Value.CheckLootRefs(m_LootTemplates, ref_set);
|
|
}
|
|
public void ReportUnusedIds(List<uint> lootIdSet)
|
|
{
|
|
// all still listed ids isn't referenced
|
|
foreach (var id in lootIdSet)
|
|
Log.outError( LogFilter.Sql, "Table '{0}' entry {1} isn't {2} and not referenced from loot, and then useless.", GetName(), id, GetEntryName());
|
|
}
|
|
public void ReportNonExistingId(uint lootId, uint ownerId)
|
|
{
|
|
Log.outError( LogFilter.Sql, "Table '{0}' Entry {1} does not exist but it is used by {2} {3}", GetName(), lootId, GetEntryName(), ownerId);
|
|
}
|
|
|
|
public bool HaveLootFor(uint loot_id) { return m_LootTemplates.LookupByKey(loot_id) != null; }
|
|
public bool HaveQuestLootFor(uint loot_id)
|
|
{
|
|
var lootTemplate = m_LootTemplates.LookupByKey(loot_id);
|
|
if (lootTemplate == null)
|
|
return false;
|
|
|
|
// scan loot for quest items
|
|
return lootTemplate.HasQuestDrop(m_LootTemplates);
|
|
}
|
|
public bool HaveQuestLootForPlayer(uint loot_id, Player player)
|
|
{
|
|
var tab = m_LootTemplates.LookupByKey(loot_id);
|
|
if (tab != null)
|
|
if (tab.HasQuestDropForPlayer(m_LootTemplates, player))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public LootTemplate GetLootFor(uint loot_id)
|
|
{
|
|
var tab = m_LootTemplates.LookupByKey(loot_id);
|
|
|
|
if (tab == null)
|
|
return null;
|
|
|
|
return tab;
|
|
}
|
|
public void ResetConditions()
|
|
{
|
|
foreach (var pair in m_LootTemplates)
|
|
{
|
|
List<Condition> empty = new List<Condition>();
|
|
pair.Value.CopyConditions(empty);
|
|
}
|
|
}
|
|
public LootTemplate GetLootForConditionFill(uint loot_id)
|
|
{
|
|
var tab = m_LootTemplates.LookupByKey(loot_id);
|
|
|
|
if (tab == null)
|
|
return null;
|
|
|
|
return tab;
|
|
}
|
|
|
|
public string GetName() { return m_name; }
|
|
string GetEntryName() { return m_entryName; }
|
|
public bool IsRatesAllowed() { return m_ratesAllowed; }
|
|
|
|
uint LoadLootTable()
|
|
{
|
|
// Clearing store (for reloading case)
|
|
Clear();
|
|
|
|
// 0 1 2 3 4 5 6 7 8
|
|
SQLResult result = DB.World.Query("SELECT Entry, Item, Reference, Chance, QuestRequired, LootMode, GroupId, MinCount, MaxCount FROM {0}", GetName());
|
|
if (result.IsEmpty())
|
|
return 0;
|
|
|
|
uint count = 0;
|
|
do
|
|
{
|
|
uint entry = result.Read<uint>(0);
|
|
uint item = result.Read<uint>(1);
|
|
uint reference = result.Read<uint>(2);
|
|
float chance = result.Read<float>(3);
|
|
bool needsquest = result.Read<bool>(4);
|
|
ushort lootmode = result.Read<ushort>(5);
|
|
byte groupid = result.Read<byte>(6);
|
|
byte mincount = result.Read<byte>(7);
|
|
byte maxcount = result.Read<byte>(8);
|
|
|
|
if (groupid >= 1 << 7) // it stored in 7 bit field
|
|
{
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} item {2}: group ({3}) must be less {4} - skipped", GetName(), entry, item, groupid, 1 << 7);
|
|
return 0;
|
|
}
|
|
|
|
LootStoreItem storeitem = new LootStoreItem(item, reference, chance, needsquest, lootmode, groupid, mincount, maxcount);
|
|
|
|
if (!storeitem.IsValid(this, entry)) // Validity checks
|
|
continue;
|
|
|
|
// Looking for the template of the entry
|
|
// often entries are put together
|
|
if (m_LootTemplates.Empty() || !m_LootTemplates.ContainsKey(entry))
|
|
m_LootTemplates.Add(entry, new LootTemplate());
|
|
|
|
// Adds current row to the template
|
|
m_LootTemplates[entry].AddEntry(storeitem);
|
|
++count;
|
|
}
|
|
while (result.NextRow());
|
|
|
|
Verify(); // Checks validity of the loot store
|
|
|
|
return count;
|
|
}
|
|
void Clear()
|
|
{
|
|
m_LootTemplates.Clear();
|
|
}
|
|
|
|
LootTemplateMap m_LootTemplates = new LootTemplateMap();
|
|
string m_name;
|
|
string m_entryName;
|
|
bool m_ratesAllowed;
|
|
}
|
|
|
|
public class LootTemplate
|
|
{
|
|
public void AddEntry(LootStoreItem item)
|
|
{
|
|
if (item.groupid > 0 && item.reference == 0) // Group
|
|
{
|
|
if (!Groups.ContainsKey(item.groupid - 1))
|
|
Groups[item.groupid - 1] = new LootGroup();
|
|
|
|
Groups[item.groupid - 1].AddEntry(item); // Adds new entry to the group
|
|
}
|
|
else // Non-grouped entries and references are stored together
|
|
Entries.Add(item);
|
|
}
|
|
|
|
public void Process(Loot loot, bool rate, ushort lootMode, byte groupId = 0)
|
|
{
|
|
if (groupId != 0) // Group reference uses own processing of the group
|
|
{
|
|
if (groupId > Groups.Count)
|
|
return; // Error message already printed at loading stage
|
|
|
|
if (Groups[groupId - 1] == null)
|
|
return;
|
|
|
|
Groups[groupId - 1].Process(loot, lootMode);
|
|
return;
|
|
}
|
|
|
|
// Rolling non-grouped items
|
|
foreach (var item in Entries)
|
|
{
|
|
if (!Convert.ToBoolean(item.lootmode & lootMode)) // Do not add if mode mismatch
|
|
continue;
|
|
|
|
if (!item.Roll(rate))
|
|
continue; // Bad luck for the entry
|
|
|
|
if (item.reference > 0) // References processing
|
|
{
|
|
LootTemplate Referenced = LootManager.Reference.GetLootFor(item.reference);
|
|
if (Referenced == null)
|
|
continue; // Error message already printed at loading stage
|
|
|
|
uint maxcount = (uint)(item.maxcount * WorldConfig.GetFloatValue(WorldCfg.RateDropItemReferencedAmount));
|
|
for (uint loop = 0; loop < maxcount; ++loop) // Ref multiplicator
|
|
Referenced.Process(loot, rate, lootMode, item.groupid);
|
|
}
|
|
else // Plain entries (not a reference, not grouped)
|
|
loot.AddItem(item); // Chance is already checked, just add
|
|
}
|
|
|
|
// Now processing groups
|
|
foreach (var group in Groups.Values)
|
|
{
|
|
if (group != null)
|
|
group.Process(loot, lootMode);
|
|
}
|
|
}
|
|
public void CopyConditions(List<Condition> conditions)
|
|
{
|
|
foreach (var i in Entries)
|
|
i.conditions.Clear();
|
|
|
|
foreach (var group in Groups.Values)
|
|
group.CopyConditions(conditions);
|
|
}
|
|
public void CopyConditions(LootItem li)
|
|
{
|
|
// Copies the conditions list from a template item to a LootItem
|
|
foreach (var item in Entries)
|
|
{
|
|
if (item.itemid != li.itemid)
|
|
continue;
|
|
|
|
li.conditions = item.conditions;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public bool HasQuestDrop(LootTemplateMap store, byte groupId = 0)
|
|
{
|
|
if (groupId != 0) // Group reference
|
|
{
|
|
if (groupId > Groups.Count)
|
|
return false; // Error message [should be] already printed at loading stage
|
|
|
|
if (Groups[groupId - 1] == null)
|
|
return false;
|
|
|
|
return Groups[groupId - 1].HasQuestDrop();
|
|
}
|
|
|
|
foreach (var item in Entries)
|
|
{
|
|
if (item.reference > 0) // References
|
|
{
|
|
var Referenced = store.LookupByKey(item.reference);
|
|
if (Referenced == null)
|
|
continue; // Error message [should be] already printed at loading stage
|
|
if (Referenced.HasQuestDrop(store, item.groupid))
|
|
return true;
|
|
}
|
|
else if (item.needs_quest)
|
|
return true; // quest drop found
|
|
}
|
|
|
|
// Now processing groups
|
|
foreach (var group in Groups.Values)
|
|
if (group.HasQuestDrop())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool HasQuestDropForPlayer(LootTemplateMap store, Player player, byte groupId = 0)
|
|
{
|
|
if (groupId != 0) // Group reference
|
|
{
|
|
if (groupId > Groups.Count)
|
|
return false; // Error message already printed at loading stage
|
|
|
|
if (Groups[groupId - 1] == null)
|
|
return false;
|
|
|
|
return Groups[groupId - 1].HasQuestDropForPlayer(player);
|
|
}
|
|
|
|
// Checking non-grouped entries
|
|
foreach (var item in Entries)
|
|
{
|
|
if (item.reference > 0) // References processing
|
|
{
|
|
var Referenced = store.LookupByKey(item.reference);
|
|
if (Referenced == null)
|
|
continue; // Error message already printed at loading stage
|
|
if (Referenced.HasQuestDropForPlayer(store, player, item.groupid))
|
|
return true;
|
|
}
|
|
else if (player.HasQuestForItem(item.itemid))
|
|
return true; // active quest drop found
|
|
}
|
|
|
|
// Now checking groups
|
|
foreach (var group in Groups.Values)
|
|
if (group.HasQuestDropForPlayer(player))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public void Verify(LootStore lootstore, uint id)
|
|
{
|
|
// Checking group chances
|
|
foreach (var group in Groups)
|
|
group.Value.Verify(lootstore, id, (byte)(group.Key + 1));
|
|
|
|
// @todo References validity checks
|
|
}
|
|
public void CheckLootRefs(LootTemplateMap store, List<uint> ref_set)
|
|
{
|
|
foreach (var item in Entries)
|
|
{
|
|
if (item.reference > 0)
|
|
{
|
|
if (LootManager.Reference.GetLootFor(item.reference) == null)
|
|
LootManager.Reference.ReportNonExistingId(item.reference, item.itemid);
|
|
else if (ref_set != null)
|
|
ref_set.Remove(item.reference);
|
|
}
|
|
}
|
|
|
|
foreach (var group in Groups.Values)
|
|
group.CheckLootRefs(store, ref_set);
|
|
}
|
|
public bool addConditionItem(Condition cond)
|
|
{
|
|
if (cond == null || !cond.isLoaded())//should never happen, checked at loading
|
|
{
|
|
Log.outError(LogFilter.Loot, "LootTemplate.addConditionItem: condition is null");
|
|
return false;
|
|
}
|
|
|
|
if (!Entries.Empty())
|
|
{
|
|
foreach (var i in Entries)
|
|
{
|
|
if (i.itemid == cond.SourceEntry)
|
|
{
|
|
i.conditions.Add(cond);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Groups.Empty())
|
|
{
|
|
foreach (var group in Groups.Values)
|
|
{
|
|
if (group == null)
|
|
continue;
|
|
|
|
LootStoreItemList itemList = group.GetExplicitlyChancedItemList();
|
|
if (!itemList.Empty())
|
|
{
|
|
foreach (var i in itemList)
|
|
{
|
|
if (i.itemid == cond.SourceEntry)
|
|
{
|
|
i.conditions.Add(cond);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
itemList = group.GetEqualChancedItemList();
|
|
if (!itemList.Empty())
|
|
{
|
|
foreach (var i in itemList)
|
|
{
|
|
if (i.itemid == cond.SourceEntry)
|
|
{
|
|
i.conditions.Add(cond);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public bool isReference(uint id)
|
|
{
|
|
foreach (var storeItem in Entries)
|
|
if (storeItem.itemid == id && storeItem.reference > 0)
|
|
return true;
|
|
|
|
return false;//not found or not reference
|
|
}
|
|
|
|
LootStoreItemList Entries = new LootStoreItemList(); // not grouped only
|
|
Dictionary<int, LootGroup> Groups = new Dictionary<int,LootGroup>(); // groups have own (optimised) processing, grouped entries go there
|
|
|
|
public class LootGroup // A set of loot definitions for items (refs are not allowed)
|
|
{
|
|
public void AddEntry(LootStoreItem item)
|
|
{
|
|
if (item.chance != 0)
|
|
ExplicitlyChanced.Add(item);
|
|
else
|
|
EqualChanced.Add(item);
|
|
}
|
|
|
|
public bool HasQuestDrop()
|
|
{
|
|
foreach (var i in ExplicitlyChanced)
|
|
if (i.needs_quest)
|
|
return true;
|
|
|
|
foreach (var i in EqualChanced)
|
|
if (i.needs_quest)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool HasQuestDropForPlayer(Player player)
|
|
{
|
|
foreach (var i in ExplicitlyChanced)
|
|
if (player.HasQuestForItem(i.itemid))
|
|
return true;
|
|
|
|
foreach (var i in EqualChanced)
|
|
if (player.HasQuestForItem(i.itemid))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public void Process(Loot loot, ushort lootMode)
|
|
{
|
|
LootStoreItem item = Roll(loot, lootMode);
|
|
if (item != null)
|
|
loot.AddItem(item);
|
|
}
|
|
float RawTotalChance()
|
|
{
|
|
float result = 0;
|
|
|
|
foreach (var i in ExplicitlyChanced)
|
|
if (!i.needs_quest)
|
|
result += i.chance;
|
|
|
|
return result;
|
|
}
|
|
float TotalChance()
|
|
{
|
|
float result = RawTotalChance();
|
|
|
|
if (!EqualChanced.Empty() && result < 100.0f)
|
|
return 100.0f;
|
|
|
|
return result;
|
|
}
|
|
|
|
public void Verify(LootStore lootstore, uint id, byte group_id = 0)
|
|
{
|
|
float chance = RawTotalChance();
|
|
if (chance > 101.0f) // @todo replace with 100% when DBs will be ready
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} group {2} has total chance > 100% ({3})", lootstore.GetName(), id, group_id, chance);
|
|
|
|
if (chance >= 100.0f && !EqualChanced.Empty())
|
|
Log.outError(LogFilter.Sql, "Table '{0}' entry {1} group {2} has items with chance=0% but group total chance >= 100% ({3})", lootstore.GetName(), id, group_id, chance);
|
|
|
|
}
|
|
public void CheckLootRefs(LootTemplateMap store, List<uint> ref_set)
|
|
{
|
|
foreach (var item in ExplicitlyChanced)
|
|
{
|
|
if (item.reference > 0)
|
|
{
|
|
if (LootManager.Reference.GetLootFor(item.reference) == null)
|
|
LootManager.Reference.ReportNonExistingId(item.reference, item.itemid);
|
|
else if (ref_set != null)
|
|
ref_set.Remove(item.reference);
|
|
}
|
|
}
|
|
|
|
foreach (var item in EqualChanced)
|
|
{
|
|
if (item.reference > 0)
|
|
{
|
|
if (LootManager.Reference.GetLootFor(item.reference) == null)
|
|
LootManager.Reference.ReportNonExistingId(item.reference, item.itemid);
|
|
else if (ref_set != null)
|
|
ref_set.Remove(item.reference);
|
|
}
|
|
}
|
|
}
|
|
public LootStoreItemList GetExplicitlyChancedItemList() { return ExplicitlyChanced; }
|
|
public LootStoreItemList GetEqualChancedItemList() { return EqualChanced; }
|
|
public void CopyConditions(List<Condition> conditions)
|
|
{
|
|
foreach (var i in ExplicitlyChanced)
|
|
i.conditions.Clear();
|
|
|
|
foreach (var i in EqualChanced)
|
|
i.conditions.Clear();
|
|
}
|
|
|
|
LootStoreItemList ExplicitlyChanced = new LootStoreItemList(); // Entries with chances defined in DB
|
|
LootStoreItemList EqualChanced = new LootStoreItemList(); // Zero chances - every entry takes the same chance
|
|
|
|
LootStoreItem Roll(Loot loot, ushort lootMode)
|
|
{
|
|
LootStoreItemList possibleLoot = ExplicitlyChanced;
|
|
possibleLoot.RemoveAll(new LootGroupInvalidSelector(loot, lootMode).Check);
|
|
|
|
if (!possibleLoot.Empty()) // First explicitly chanced entries are checked
|
|
{
|
|
float roll = (float)RandomHelper.randChance();
|
|
|
|
foreach (var item in possibleLoot) // check each explicitly chanced entry in the template and modify its chance based on quality.
|
|
{
|
|
if (item.chance >= 100.0f)
|
|
return item;
|
|
|
|
roll -= item.chance;
|
|
if (roll < 0)
|
|
return item;
|
|
}
|
|
}
|
|
|
|
possibleLoot = EqualChanced;
|
|
possibleLoot.RemoveAll(new LootGroupInvalidSelector(loot, lootMode).Check);
|
|
if (!possibleLoot.Empty()) // If nothing selected yet - an item is taken from equal-chanced part
|
|
return possibleLoot.SelectRandom();
|
|
|
|
return null; // Empty drop from the group
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct LootGroupInvalidSelector
|
|
{
|
|
public LootGroupInvalidSelector(Loot loot, ushort lootMode)
|
|
{
|
|
_loot = loot;
|
|
_lootMode = lootMode;
|
|
}
|
|
|
|
public bool Check(LootStoreItem item)
|
|
{
|
|
if (!Convert.ToBoolean(item.lootmode & _lootMode))
|
|
return true;
|
|
|
|
byte foundDuplicates = 0;
|
|
foreach (var lootItem in _loot.items)
|
|
if (lootItem.itemid == item.itemid)
|
|
if (++foundDuplicates == _loot.maxDuplicates)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
Loot _loot;
|
|
ushort _lootMode;
|
|
}
|
|
}
|