private ArmorParams GetArmorParams(PreCharParams arg)
{
var csv = new List <string>();
if (arg.Armors.ContainsKey(SINGULAR))
{
csv = GetEquipmentCSV(arg.Armors[SINGULAR]);
}
if (csv != null && csv.Count >= 3)
{
try
{
var key = csv[PredefinedEquipmentXMLIndexes.NAME] + "_" + csv[PredefinedEquipmentXMLIndexes.TIER];
var armor = ArmorParamTable.Instance.Table[key];
armor.Sprites = EquipmentSpritesTable.Instance.Table[key];
return(armor);
}
catch (KeyNotFoundException e)
{
var key = csv[PredefinedEquipmentXMLIndexes.NAME] + "_" + csv[PredefinedEquipmentXMLIndexes.TIER];
Debug.LogError(key + " was not found");
Debug.LogError(e.Message);
return(null);
}
}
else
{
return(null);
}
}
private WeaponParams GetWpnParams(PreCharParams arg, Dictionary <string, List <List <string> > > table)
{
var csv = new List <string>();
if (table.ContainsKey(SINGULAR))
{
csv = GetEquipmentCSV(table[SINGULAR]);
}
if (csv != null && csv.Count >= 3)
{
var key = csv[PredefinedEquipmentXMLIndexes.NAME] + "_" + csv[PredefinedEquipmentXMLIndexes.TIER];
if (WeaponParamTable.Instance.Table.ContainsKey(key))
{
var weapon = WeaponParamTable.Instance.Table[key];
weapon.Sprites = EquipmentSpritesTable.Instance.Table[key];
return(weapon);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
private MChar BuildHelper(PreCharParams preCharParams)
{
var character = new MChar(preCharParams.Race);
if (preCharParams.Race != ERace.Critter && preCharParams.Race != ERace.None)
{
var racialPerks = RaceParamsTable.Instance.Table[preCharParams.Race].DefaultPerks;
PerkMediator.Instance.SetCharacterPerks(character, racialPerks);
}
PerkMediator.Instance.SetCharacterPerks(character, preCharParams.Perks);
this.BuildBaseClassHelper(preCharParams, character);
this.BuildAbilities(preCharParams, character);
this.BuildCharStats(preCharParams, character);
this.BuildClassPrimaryStats(character);
var secondary = GetSecondaryStats(character.GetBaseStats().GetPrimaryStats());
character.GetBaseStats().SetSecondaryStats(secondary);
this.BuildClassSecondaryStats(character);
this.BuildCurStats(character);
this.BuildCurPoints(character);
character.SetType(preCharParams.Type);
character.SetParams(preCharParams);
this.BuildCharMount(preCharParams, character);
character.SetAIRole(preCharParams.AIRole);
return(character);
}
private VChar GetRandomCritter(PreCharParams c)
{
var p = new VChar();
p.Sprites = CharSpriteLoader.Instance.GetCritterSprites(c);
return(p);
}
private PStats GetRaceStats(PreCharParams c)
{
if (RaceParamsTable.Instance.Table.ContainsKey(c.Race))
{
return(RaceParamsTable.Instance.Table[c.Race].PrimaryStats.Clone());
}
else
{
return(null);
}
}
private void BuildBaseClassHelper(PreCharParams p, MChar c)
{
var builder = new ClassBuilder();
foreach (var kvp in p.Classes)
{
var toAdd = builder.Build(kvp.Key);
toAdd.Level = kvp.Value;
c.GetBaseClasses().Add(kvp.Key, toAdd);
}
}
public VChar GetRandomizedCharacterSprites(PreCharParams c)
{
var random = new VChar();
switch (c.Type)
{
case (ECharType.Critter): { random = GetRandomCritter(c); } break;
case (ECharType.Humanoid): { random = GetRandomHumanoid(c); } break;
}
return(random);
}
private void BuildCharStats(PreCharParams preCharParams, MChar character)
{
var raceStats = this.GetRaceStats(preCharParams);
if (raceStats == null)
{
var specificStats = PredefinedCharTable.Instance.Table[preCharParams.Name];
character.GetBaseStats().SetPrimaryStats(specificStats.Stats);
}
else
{
character.GetBaseStats().SetPrimaryStats(raceStats);
}
}
private void BuildCharMount(PreCharParams preCharParams, MChar character)
{
if (preCharParams.Type == Enum.ECharType.Humanoid)
{
var builder = new MountBuilder();
this.BuildArmorHelper(character, preCharParams);
this.BuildWeaponHelper(character, preCharParams);
var mountParams = this.GetMountParams(preCharParams);
if (mountParams != null)
{
character.SetMount(builder.Build(mountParams));
}
}
}
private MountParams GetMountParams(PreCharParams arg)
{
if (arg.Mount != EMount.None)
{
var mount = new MountParams();
var mParams = MountsTable.Instance.Table[arg.Mount];
mount.Type = arg.Mount;
return(mount);
}
else
{
return(null);
}
}
private void BuildAbilities(PreCharParams p, MChar c)
{
foreach (var kvp in p.AbilityEffectDict)
{
var ability = AbilityFactory.Instance.CreateNewObject(kvp.Key);
ability.Data.Effects.AddRange(kvp.Value);
c.GetAbilitiesContainer().AddAbility(ability);
}
var wpnAbs = WeaponAbilityFactory.Instance.CreateNewObject(p.WpnAbilities);
foreach (var v in wpnAbs)
{
c.GetAbilitiesContainer().AddAbility(v);
}
}
private VChar GetRandomHumanoid(PreCharParams c)
{
var p = new VChar();
var table = RaceParamsTable.Instance.Table;
p.Face = ListUtil <int> .GetRandomElement(table[c.Race].Sprites.Face);
if (table[c.Race].Sprites.HeadDeco1.Count > 0)
{
p.HeadDeco1 = ListUtil <int> .GetRandomElement(table[c.Race].Sprites.HeadDeco1);
}
else
{
p.HeadDeco1 = -1;
}
if (table[c.Race].Sprites.HeadDeco2.Count > 0)
{
p.HeadDeco2 = ListUtil <int> .GetRandomElement(table[c.Race].Sprites.HeadDeco2);
}
else
{
p.HeadDeco2 = -1;
}
if (table[c.Race].Sprites.TorsoDeco1.Count > 0)
{
p.TorsoDeco1 = ListUtil <int> .GetRandomElement(table[c.Race].Sprites.TorsoDeco1);
}
else
{
p.TorsoDeco1 = -1;
}
if (table[c.Race].Sprites.TorsoDeco2.Count > 0)
{
p.TorsoDeco2 = ListUtil <int> .GetRandomElement(table[c.Race].Sprites.TorsoDeco2);
}
else
{
p.TorsoDeco2 = -1;
}
p.Torso = ListUtil <int> .GetRandomElement(table[c.Race].Sprites.Torso);
p.Head = p.Torso - TORSO_OFFSET;
p.Sprites = CharSpriteLoader.Instance.GetCharacterSprites(c);
return(p);
}
private ArmorParams GetHelmParams(PreCharParams arg)
{
var csv = new List <string>();
if (arg.Helms.ContainsKey(SINGULAR))
{
csv = GetEquipmentCSV(arg.Helms[SINGULAR]);
}
if (csv != null && csv.Count >= 3)
{
var key = csv[PredefinedEquipmentXMLIndexes.NAME] + "_" + csv[PredefinedEquipmentXMLIndexes.TIER];
var helm = ArmorParamTable.Instance.Table[key];
helm.Sprites = EquipmentSpritesTable.Instance.Table[key];
return(helm);
}
else
{
return(null);
}
}
private void BuildWeaponHelper(MChar c, PreCharParams p)
{
var rWpnParams = this.GetWpnParams(p, p.RWeapons);
var lWpnParams = this.GetWpnParams(p, p.LWeapons);
if (rWpnParams != null)
{
var weapon = WeaponFactory.Instance.CreateNewObject(
rWpnParams.Name,
rWpnParams.Tier);
c.GetEquipment().AddWeapon(weapon, false);
}
if (lWpnParams != null)
{
var weapon = WeaponFactory.Instance.CreateNewObject(
lWpnParams.Name,
lWpnParams.Tier);
c.GetEquipment().AddWeapon(weapon, true);
}
}
private void BuildArmorHelper(MChar c, PreCharParams p)
{
var armorParams = this.GetArmorParams(p);
if (armorParams != null)
{
var armor = ArmorFactory.Instance.CreateNewObject(
armorParams.Name,
armorParams.Tier);
c.GetEquipment().AddArmor(armor);
}
var helmParams = this.GetHelmParams(p);
if (helmParams != null)
{
var helm = HelmFactory.Instance.CreateNewObject(
helmParams.Name,
helmParams.Tier);
c.GetEquipment().AddHelm(helm);
}
}
public void SetParams(PreCharParams p)
{
this._params = p;
}
public Sprite[] GetCritterSprites(PreCharParams c)
{
var path = StringUtil.PathBuilder(CRITTER_PATH, c.Name, EXTENSION);
return(GetSprites(path));
}
public Sprite[] GetCharacterSprites(PreCharParams c)
{
var path = StringUtil.PathBuilder(CHARACTER_PATH, c.Race.ToString(), EXTENSION);
return(GetSprites(path));
}
public MChar CreateNewCharacter(PreCharParams arg)
{
return(this._charBuilder.Build(arg));
}
public MChar Build(PreCharParams arg)
{
return(BuildHelper(arg));
}
