public override void Convert(byte[] rawData)
{
var raceClassGender = GetUInt32(rawData, 1);
var race = (RaceId)(raceClassGender & 0xFF);
var clss = (ClassId)((raceClassGender & 0xFF00) >> 8);
var gender = (GenderType)((raceClassGender & 0xFF0000) >> 16);
var archetype = ArchetypeMgr.GetArchetype(race, clss);
if (archetype == null)
{
return;
}
var items = archetype.GetInitialItems(gender);
for (var i = 2; i <= 25; i++)
{
var itemId = GetInt32(rawData, i);
if (itemId > 0)
{
var templ = ItemMgr.GetTemplate((ItemId)itemId);
if (templ == null)
{
LogManager.GetCurrentClassLogger().Warn("Missing initial Item in DB: " + itemId + " (" + (uint)itemId + ")");
}
else
{
if (templ.IsStackable)
{
var index = items.FindIndex(stack => stack.Template.Id == itemId);
if (index > -1)
{
items[index] = new ItemStack
{
Template = templ,
Amount = items[index].Amount + 1
};
}
else
{
items.Add(new ItemStack
{
Template = templ,
Amount = templ.IsAmmo ? templ.MaxAmount : 1
});
}
}
else
{
items.Add(new ItemStack
{
Template = templ,
Amount = 1
});
}
}
}
}
}
public static void Initialize()
{
if (ArchetypeMgr.loaded)
{
return;
}
ArchetypeMgr.InitClasses();
ArchetypeMgr.InitRaces();
ContentMgr.Load <Archetype>();
if (ItemMgr.Loaded)
{
ArchetypeMgr.LoadItems();
}
for (int index = 0; index < SpellLines.SpellLinesByClass.Length; ++index)
{
SpellLine[] spellLineArray = SpellLines.SpellLinesByClass[index];
if (spellLineArray != null)
{
BaseClass baseClass = ArchetypeMgr.GetClass((ClassId)index);
if (baseClass != null)
{
baseClass.SpellLines = spellLineArray;
}
}
}
ArchetypeMgr.loaded = true;
}
public void FinalizeDataHolder()
{
Spell spell = SpellHandler.Get(this.SpellId);
if (spell == null)
{
ContentMgr.OnInvalidDBData(this.GetType().Name + " for \"{0} {1}\" refers to invalid Spell: {2}.",
(object)this.Race, (object)this.Class, (object)this);
}
else
{
List <Archetype> archetypes = ArchetypeMgr.GetArchetypes(this.Race, this.Class);
if (archetypes == null)
{
ContentMgr.OnInvalidDBData(this.GetType().Name + " \"{0}\" refers to invalid Archetype: {1} {2}.",
(object)this, (object)this.Race, (object)this.Class);
}
else
{
foreach (Archetype archetype in archetypes)
{
archetype.Spells.Add(spell);
}
}
}
}
public void FinalizeDataHolder()
{
this.Race = ArchetypeMgr.GetRace(this.RaceId);
this.Class = ArchetypeMgr.GetClass(this.ClassId);
if (this.Class != null)
{
BaseRace race = this.Race;
}
Archetype[] archetypeArray = ArchetypeMgr.Archetypes[(uint)this.ClassId];
if (archetypeArray == null)
{
ArchetypeMgr.Archetypes[(uint)this.ClassId] =
archetypeArray = new Archetype[WCellConstants.RaceTypeLength];
}
this.StartLocation =
(IWorldZoneLocation) new WorldZoneLocation(this.StartMapId, this.StartPosition, this.StartZoneId);
if (this.StartLocation.Map == null)
{
LogManager.GetCurrentClassLogger().Warn("Failed to initialize Archetype \"" + (object)this +
"\" - StartMap does not exist: " + (object)this.StartMapId);
}
else
{
archetypeArray[(uint)this.RaceId] = this;
}
}
public override void Convert(byte[] rawData)
{
uint uint32 = DBCRecordConverter.GetUInt32(rawData, 1);
RaceId race = (RaceId)((int)uint32 & (int)byte.MaxValue);
ClassId clssId = (ClassId)((uint32 & 65280U) >> 8);
GenderType gender = (GenderType)((uint32 & 16711680U) >> 16);
Archetype archetype = ArchetypeMgr.GetArchetype(race, clssId);
if (archetype == null)
{
return;
}
List <ItemStack> initialItems = archetype.GetInitialItems(gender);
for (int field = 2; field <= 25; ++field)
{
int itemId = DBCRecordConverter.GetInt32(rawData, field);
if (itemId > 0)
{
ItemTemplate template = ItemMgr.GetTemplate((Asda2ItemId)itemId);
if (template == null)
{
LogManager.GetCurrentClassLogger()
.Warn("Missing initial Item in DB: " + (object)itemId + " (" + (object)(uint)itemId +
")");
}
else if (template.IsStackable)
{
int index = initialItems.FindIndex((Predicate <ItemStack>)(stack =>
(long)stack.Template.Id == (long)itemId));
if (index > -1)
{
initialItems[index] = new ItemStack()
{
Template = template,
Amount = initialItems[index].Amount + 1
}
}
;
else
{
initialItems.Add(new ItemStack()
{
Template = template,
Amount = template.IsAmmo ? template.MaxAmount : 1
});
}
}
else
{
initialItems.Add(new ItemStack()
{
Template = template,
Amount = 1
});
}
}
}
}
public static void EnsureInitialize()
{
if (ArchetypeMgr.ClassCreators[1] != null)
{
return;
}
ArchetypeMgr.Initialize();
}
private static void InitClasses()
{
ArchetypeMgr.AddClass((BaseClass) new OHSClass());
ArchetypeMgr.AddClass((BaseClass) new SpearClass());
ArchetypeMgr.AddClass((BaseClass) new THSClass());
ArchetypeMgr.AddClass((BaseClass) new CrossbowClass());
ArchetypeMgr.AddClass((BaseClass) new BowClass());
ArchetypeMgr.AddClass((BaseClass) new BalistatClass());
ArchetypeMgr.AddClass((BaseClass) new AtackMageClass());
ArchetypeMgr.AddClass((BaseClass) new SupportMageClass());
ArchetypeMgr.AddClass((BaseClass) new HealMageClass());
ArchetypeMgr.AddClass((BaseClass) new NoviceClass());
}
public void FinalizeDataHolder()
{
var clss = ArchetypeMgr.GetClass(ClassId);
if (clss == null)
{
ContentMgr.OnInvalidDBData("Invalid ClassId in BaseClassSetting: {0} ({1})", ClassId, (int)ClassId);
}
else
{
ArrayUtil.Set(ref clss.Settings, Level, this);
}
}
public void FinalizeDataHolder()
{
BaseClass baseClass = ArchetypeMgr.GetClass(this.ClassId);
if (baseClass == null)
{
ContentMgr.OnInvalidDBData("Invalid ClassId in BaseClassSetting: {0} ({1})", (object)this.ClassId,
(object)(int)this.ClassId);
}
else
{
ArrayUtil.Set <ClassLevelSetting>(ref baseClass.Settings, this.Level, this);
}
}
public void FinalizeDataHolder()
{
var archetypes = ArchetypeMgr.GetArchetypes(Race, Class);
if (archetypes == null)
{
ContentMgr.OnInvalidDBData(GetType().Name + " \"{0}\" refers to invalid Archetype: {1} {2}.", this, Race, Class);
}
else
{
foreach (var archetype in archetypes)
{
ActionButton.Set(archetype.ActionButtons, Index, Action, Type, Info);
}
}
}
public void FinalizeDataHolder()
{
var level = Level > 0 ? Level : 1;
if (level > RealmServerConfiguration.MaxCharacterLevel)
{
return;
}
var archetype = ArchetypeMgr.GetArchetype(Race, Class);
if (Level == 1)
{
archetype.FirstLevelStats = this;
}
archetype.LevelStats[level - 1] = this;
}
public void FinalizeDataHolder()
{
List <Archetype> archetypes = ArchetypeMgr.GetArchetypes(this.Race, this.Class);
if (archetypes == null)
{
ContentMgr.OnInvalidDBData(this.GetType().Name + " \"{0}\" refers to invalid Archetype: {1} {2}.",
(object)this, (object)this.Race, (object)this.Class);
}
else
{
foreach (Archetype archetype in archetypes)
{
ActionButton.Set(archetype.ActionButtons, this.Index, this.Action, this.Type, this.Info);
}
}
}
public void FinalizeDataHolder()
{
int num = Level > 0 ? Level : 1;
if (num > RealmServerConfiguration.MaxCharacterLevel)
{
return;
}
Archetype archetype = ArchetypeMgr.GetArchetype(Race, Class);
if (archetype == null)
{
return;
}
if (Level == 1)
{
archetype.FirstLevelStats = this;
}
archetype.LevelStats[num - 1] = this;
}
public void FinalizeDataHolder()
{
Race = ArchetypeMgr.GetRace(RaceId);
Class = ArchetypeMgr.GetClass(ClassId);
if (Class == null || Race == null)
{
//throw new ContentException("Could not load Archetype \"{0}\" - Invalid Class or race.", this);
}
var races = ArchetypeMgr.Archetypes[(uint)ClassId];
if (races == null)
{
ArchetypeMgr.Archetypes[(uint)ClassId] = races = new Archetype[WCellConstants.RaceTypeLength];
}
StartLocation = new WorldZoneLocation(StartMapId, StartPosition, StartZoneId);
if (StartLocation.Map == null)
{
LogManager.GetCurrentClassLogger().Warn("Failed to initialize Archetype \"" + this + "\" - StartMap does not exist: " + StartMapId);
//ArrayUtil.Set(ref RaceClassMgr.BaseRaces, (uint)Id, null);
}
else
{
/*if (StartLocation.ZoneTemplate == null)
* {
* LogManager.GetCurrentClassLogger().Warn("Failed to initialize Archetype \"" + this +
* "\" - StartZone \"" + StartZoneId + "\" does not exist in StartMap \"" +
* StartMapId + "\"");
* //ArrayUtil.Set(ref RaceClassMgr.BaseRaces, (uint)Id, null);
* }
* else
* {*/
races[(uint)RaceId] = this;
//}
}
//get levelstats
}
public void FinalizeDataHolder()
{
var spell = SpellHandler.Get(SpellId);
if (spell == null)
{
ContentMgr.OnInvalidDBData(GetType().Name + " for \"{0} {1}\" refers to invalid Spell: {2}.", Race, Class, this);
}
else
{
var archetypes = ArchetypeMgr.GetArchetypes(Race, Class);
if (archetypes == null)
{
ContentMgr.OnInvalidDBData(GetType().Name + " \"{0}\" refers to invalid Archetype: {1} {2}.", this, Race, Class);
}
else
{
foreach (var archetype in archetypes)
{
archetype.Spells.Add(spell);
}
}
}
}
