public static void ModArmorPiece(string setName, string location, ref ItemDrop.ItemData piece, JToken values, bool isNewSet, int i)
{
ArmorSet armor = ArmorSets[setName];
JToken tierBalance;
if (isNewSet)
{
tierBalance = values["upgrades"][$"t{i}"];
}
else
{
tierBalance = values;
if (setName != "barbarian")
{
piece.m_shared.m_name = $"{armor.HelmetName}0";
}
}
StatusEffect setEffect = GetSetEffect((string)values["setEffect"], tierBalance);
piece.m_shared.m_armor = (float)tierBalance["baseArmor"];
piece.m_shared.m_armorPerLevel = (float)tierBalance["armorPerLevel"];
if (setEffect != null)
{
piece.m_shared.m_setStatusEffect = setEffect;
}
else
{
Log.LogWarning($"{setName} - No set effect found for provided effect: {(string)values["setEffect"]}");
}
piece.m_shared.m_setSize = (setName != "rags" ? 3 : 2);
piece.m_shared.m_setName = (string)values["name"];
if (!piece.m_shared.m_name.Contains("helmet"))
{
piece.m_shared.m_movementModifier = (float)tierBalance["globalMoveMod"];
}
piece.m_shared.m_description = $"<i>{armor.ClassName}</i>\n{piece.m_shared.m_description}";
if (location == "head")
{
piece.m_shared.m_armor += armor.HelmetArmor;
}
StatusEffect status = GetArmorEffect((string)values[$"{location}Effect"], tierBalance, location, ref piece.m_shared.m_description);
if ((string)values[$"{location}Effect"] == "challengemvespd")
{
piece.m_shared.m_movementModifier += (float)values[$"{location}EffectVal"];
}
if (status != null)
{
piece.m_shared.m_equipStatusEffect = status;
}
else
{
Log.LogWarning($"{setName} {location} - No status effect found for provided effect: {(string)values[$"{location}Effect"]}");
}
}
public void SetArmorSet(ArmorSet armorSet)
{
ArmorSet = armorSet;
for (int i = armorSetContainer.childCount - 1; i >= 0; i--)
{
Destroy(armorSetContainer.GetChild(i).gameObject);
}
RectTransform armorRect = Instantiate(armorSet.gameObject, armorSetContainer).GetComponent <RectTransform>();
armorRect.anchoredPosition = Vector2.zero;
}
public ArmorSetViewModel(ArmorSet armorSet)
{
Head = armorSet.ArmorPieces[0];
Torso = armorSet.ArmorPieces[1];
Waist = armorSet.ArmorPieces[2];
Arms = armorSet.ArmorPieces[3];
Legs = armorSet.ArmorPieces[4];
RarityMin = armorSet.ArmorPieces.Min(x => x.Rarity);
RarityMax = armorSet.ArmorPieces.Max(x => x.Rarity);
}
public static List <ArmorSet> Search(string query)
{
List <ArmorSet> result = new List <ArmorSet>();
Tokenizer tokenizer = new Tokenizer(
Marshal.PtrToStringAnsi(DoSearch(query)));
ArmorSet answer = new ArmorSet();
while (ArmorSet.Parse(ref tokenizer, out answer))
{
result.Add(answer);
}
return(result);
}
public ItemLibraryArmorSet this[ArmorSet set]
{
get
{
foreach (ItemLibraryArmorSet s in armorSets)
{
if (s.armorSet == set)
{
return(s);
}
}
return(null);
}
}
public User(string username, string email, string password, long id, string firstName, string lastName, int healthPoints, int lvl, int exp, int credits, int paidCredits)
{
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.healthPoints = healthPoints;
this.lvl = lvl;
this.exp = exp;
this.credits = credits;
this.paidCredits = paidCredits;
//this.lastLogin = DateTime.Now;
this.username = username;
this.email = email;
//this.sinceDate = DateTime.Today;
this.armorSet = new ArmorSet();
this.wepSet = new WeaponSet();
this.inventory = new Inventory();
this.healthPoints = 100;
this.lvl = 1;
this.exp = 0;
this.credits = 1000;
this.paidCredits = 10;
}
public static List<ArmorSet> Search(string query) {
List<ArmorSet> result = new List<ArmorSet>();
Tokenizer tokenizer = new Tokenizer(
Marshal.PtrToStringAnsi(DoSearch(query)));
ArmorSet answer = new ArmorSet();
while (ArmorSet.Parse(ref tokenizer, out answer)) {
result.Add(answer);
}
return result;
}
public static bool Parse(ref Tokenizer tokenizer, out ArmorSet answer) {
answer = new ArmorSet();
if (!tokenizer.Expect(TokenName.OPEN_PARENTHESIS)) {
return false;
}
do {
Instruction instruction = ReadInstruction(ref tokenizer);
switch (instruction) {
case Instruction.GEAR:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.gear)) {
return false;
}
answer.weapon_slots = answer.gear.id;
break;
case Instruction.HEAD:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.head)) {
return false;
}
break;
case Instruction.BODY:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.body)) {
return false;
}
break;
case Instruction.ARMS:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.arms)) {
return false;
}
break;
case Instruction.WAIST:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.waist)) {
return false;
}
break;
case Instruction.LEGS:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.legs)) {
return false;
}
break;
case Instruction.AMULET:
if (!Amulet.Parse(ref tokenizer, out answer.amulet)) {
return false;
}
break;
case Instruction.COMPLETE:
return true;
default:
return false;
}
} while (!tokenizer.Empty());
return false;
}
public override void AddArmorVisible(ArmorTypes type)
{
int armorSetIndex = GetArmorSetIndex(type);
ArmorSet armorSet = (armorSetIndex == -1) ? null : ArmorSets[armorSetIndex];
if (type == ArmorTypes.Warmsuit)
{
for (int i = 0; i < 10; i++)
{
int num = i;
if (CurrentArmorTypes[num] != 0)
{
ArmorTypes type2 = CurrentArmorTypes[num];
int armorSetIndex2 = GetArmorSetIndex(type2);
ArmorSet armorSet2 = ArmorSets[armorSetIndex2];
ToggleArmorPiece(armorSet2.ModelType, armorSet2.Mat, num, false);
ToggleArmorPiece(armorSet2.ModelType2, armorSet2.Mat2, num, false);
if (UpgradePointsMod.instance.specialUpgrades[5].bought)
{
for (int x = 0; x < armorSet.Effects.Length; x++)
{
if (armorSet.Effects[x]._type == StatEffect.Types.Armor)
{
armorSet.Effects[x]._amount *= 2;
}
}
}
ItemUtils.ApplyEffectsToStats(armorSet2.Effects, false, 1);
if (armorSet2.HP - CurrentArmorHP[num] < 4 && !Player.AddItem(armorSet2.ItemId, 1, false, false, null))
{
LocalPlayer.Inventory.FakeDrop(armorSet2.ItemId, null);
}
CurrentArmorTypes[num] = ArmorTypes.None;
}
}
ArmorVis = 0;
CurrentArmorTypes[0] = ArmorTypes.Warmsuit;
GetArmorPiece(ArmorTypes.Warmsuit, 0).SetActive(true);
if (UpgradePointsMod.instance.specialUpgrades[5].bought)
{
for (int x = 0; x < armorSet.Effects.Length; x++)
{
if (armorSet.Effects[x]._type == StatEffect.Types.Armor)
{
armorSet.Effects[x]._amount *= 2;
}
}
}
ItemUtils.ApplyEffectsToStats(armorSet.Effects, true, 1);
UpdateArmorNibbles();
LocalPlayer.Clothing.RefreshVisibleClothing();
}
else
{
if (!Warmsuit)
{
for (int j = 0; j < 10; j++)
{
int num2 = (int)Mathf.Repeat((float)(ArmorVis + j), 10f);
if (CurrentArmorTypes[num2] == ArmorTypes.None)
{
CurrentArmorTypes[num2] = type;
if (armorSet != null)
{
ToggleArmorPiece(armorSet.ModelType, armorSet.Mat, num2, true);
ToggleArmorPiece(armorSet.ModelType2, armorSet.Mat2, num2, true);
CurrentArmorHP[num2] = armorSet.HP;
ArmorVis = num2 + 1;
if (UpgradePointsMod.instance.specialUpgrades[5].bought)
{
for (int x = 0; x < armorSet.Effects.Length; x++)
{
if (armorSet.Effects[x]._type == StatEffect.Types.Armor)
{
armorSet.Effects[x]._amount *= 2;
}
}
}
ItemUtils.ApplyEffectsToStats(armorSet.Effects, true, 1);
}
UpdateArmorNibbles();
return;
}
}
}
if (ArmorVis == 10)
{
ArmorVis = 0;
}
if (CurrentArmorTypes[ArmorVis] != 0)
{
ArmorTypes type3 = CurrentArmorTypes[ArmorVis];
int armorSetIndex3 = GetArmorSetIndex(type3);
ArmorSet armorSet3 = ArmorSets[armorSetIndex3];
ToggleArmorPiece(armorSet3.ModelType, armorSet3.Mat, ArmorVis, false);
ToggleArmorPiece(armorSet3.ModelType2, armorSet3.Mat2, ArmorVis, false);
if (UpgradePointsMod.instance.specialUpgrades[5].bought)
{
for (int x = 0; x < armorSet.Effects.Length; x++)
{
if (armorSet.Effects[x]._type == StatEffect.Types.Armor)
{
armorSet.Effects[x]._amount *= 2;
}
}
}
ItemUtils.ApplyEffectsToStats(armorSet3.Effects, false, 1);
if (armorSet3.HP - CurrentArmorHP[ArmorVis] < 4 && !Warmsuit && !Player.AddItem(armorSet3.ItemId, 1, false, false, null))
{
LocalPlayer.Inventory.FakeDrop(armorSet3.ItemId, null);
}
if (Warmsuit)
{
CurrentArmorTypes[ArmorVis] = ArmorTypes.None;
LocalPlayer.Inventory.UnequipItemAtSlot(Item.EquipmentSlot.FullBody, false, true, false);
LocalPlayer.Clothing.RefreshVisibleClothing();
}
}
CurrentArmorHP[ArmorVis] = (armorSet?.HP ?? 0);
CurrentArmorTypes[ArmorVis] = type;
if (armorSet != null)
{
ToggleArmorPiece(armorSet.ModelType, armorSet.Mat, ArmorVis, true);
ToggleArmorPiece(armorSet.ModelType2, armorSet.Mat2, ArmorVis, true);
if (UpgradePointsMod.instance.specialUpgrades[5].bought)
{
for (int x = 0; x < armorSet.Effects.Length; x++)
{
if (armorSet.Effects[x]._type == StatEffect.Types.Armor)
{
armorSet.Effects[x]._amount *= 2;
}
}
}
ItemUtils.ApplyEffectsToStats(armorSet.Effects, true, 1);
ArmorVis++;
}
UpdateArmorNibbles();
}
}
public void Write(Random random, RandomizerOptions options)
{
// Collect game items
// For armor: headEquip/bodyEquip/armEquip/legEquip booleans. weight float
// For weapons: weight float.
// Requirements: correctStrength/correctAgility/corretMagic/corretFaith float.
// Types: displayTypeId (maps to MenuValueTableParam, in FMGs).
// enablePyromancy/enablePyromancy/enableMiracle bool? Check attack types other than isBlowAttackType for whether a proper weapon
// rightHandEquipable/leftHandEquipable bool (bothHandEquipable)?
// arrowSlotEquipable/boltSlotEquipable bool for bows. bool DisableShoot for greatbow
// enableGuard for shield
// Arrows/Bolts: eh a bit tricky. weaponCategory 13/14 for arrow/bolt, and bool DisableShoot for greatbow
// Spells: in Magic table. requirementIntellect, requirementFaith. ezStateBehaviorType - 0 magic, 2 pyro, 1 miracle
Dictionary <EquipCategory, List <ItemKey> > items = new Dictionary <EquipCategory, List <ItemKey> >();
Dictionary <ItemKey, float> weights = new Dictionary <ItemKey, float>();
Dictionary <ItemKey, StatReq> requirements = new Dictionary <ItemKey, StatReq>();
HashSet <ItemKey> crossbows = new HashSet <ItemKey>();
PARAM magics = game.Param("Magic");
bool twoHand = options["startingtwohand"];
foreach (ItemKey key in data.Data.Keys)
{
if (key.Type == ItemType.WEAPON)
{
PARAM.Row row = game.Item(key);
EquipCategory mainCat = EquipCategory.WEAPON;
int weaponCategory = (byte)row["weaponCategory"].Value;
if (weaponCategories.ContainsKey(weaponCategory))
{
mainCat = weaponCategories[weaponCategory];
}
if ((byte)row["enableGuard"].Value == 1)
{
mainCat = EquipCategory.SHIELD;
}
if (mainCat == EquipCategory.BOW || mainCat == EquipCategory.ARROW || mainCat == EquipCategory.BOLT)
{
// Disable greatbow for starting - requirements too far off
if ((byte)row["DisableShoot"].Value == 1)
{
continue;
}
}
if (mainCat == EquipCategory.BOW)
{
if ((byte)row["boltSlotEquipable"].Value == 1)
{
crossbows.Add(key);
}
}
if (mainCat != EquipCategory.UNSET)
{
AddMulti(items, mainCat, key);
}
if ((byte)row["enableMagic"].Value == 1)
{
AddMulti(items, EquipCategory.CATALYST, key);
}
if ((byte)row["enableMiracle"].Value == 1)
{
AddMulti(items, EquipCategory.TALISMAN, key);
}
if ((byte)row["enablePyromancy"].Value == 1)
{
AddMulti(items, EquipCategory.FLAME, key);
}
int str = (byte)row["properStrength"].Value;
// Add two hand adjustment for weapons. Note this doesn't work exactly for casting items, but does not affect casting.
if (twoHand && (byte)row["Unk14"].Value == 0 && (mainCat == EquipCategory.WEAPON || mainCat == EquipCategory.UNSET))
{
str = (int)Math.Ceiling(str / 1.5);
}
requirements[key] = new StatReq
{
Str = (sbyte)str,
Dex = (sbyte)(byte)row["properAgility"].Value,
Mag = (sbyte)(byte)row["properMagic"].Value,
Fai = (sbyte)(byte)row["properFaith"].Value,
};
weights[key] = (float)row["weight"].Value;
}
else if (key.Type == ItemType.ARMOR)
{
PARAM.Row row = game.Item(key);
for (int i = 0; i < 4; i++)
{
if ((byte)row[armorTypes[i]].Value == 1)
{
AddMulti(items, armorCats[i], key);
weights[key] = (float)row["weight"].Value;
break;
}
}
}
else if (key.Type == ItemType.GOOD)
{
PARAM.Row magic = magics[key.ID];
// Exclude Spook and Tears of Denial as they can be a key item, useful though they are
if (magic != null && key.ID != 1354000 && key.ID != 3520000)
{
int magicCat = (byte)magic["ezStateBehaviorType"].Value;
AddMulti(items, magicTypes[magicCat], key);
requirements[key] = new StatReq
{
Str = 0,
Dex = 0,
Mag = (sbyte)(byte)magic["requirementIntellect"].Value,
Fai = (sbyte)(byte)magic["requirementFaith"].Value,
Att = (sbyte)(byte)magic["slotLength"].Value,
};
}
}
}
// Generate some armor sets. One downside of this approach is that each piece is represented only once - but it is just one shuffle per category, and tends to result in a similar distribution to normal.
List <List <ItemKey> > weightedArmors = new List <List <ItemKey> >();
for (int i = 0; i < 4; i++)
{
weightedArmors.Add(WeightedShuffle(random, items[armorCats[i]], item => 1 / weights[item]));
}
List <ArmorSet> armors = new List <ArmorSet>();
int maxArmors = weightedArmors.Select(rank => rank.Count).Min();
for (int num = 0; num < maxArmors; num++)
{
ArmorSet armor = new ArmorSet();
for (int i = 0; i < 4; i++)
{
ItemKey item = weightedArmors[i][num];
armor.Ids[i] = item.ID;
armor.Weight += weights[item];
}
armors.Add(armor);
}
armors.Sort((a, b) => a.Weight.CompareTo(b.Weight));
PARAM chara = game.Param("CharaInitParam");
// Just for testing ;)
bool cheat = false;
for (int i = 0; i < 10; i++)
{
PARAM.Row row = chara[startId + i];
// First, always fudge magic to 10, so that Orbeck quest is possible.
if ((sbyte)row["baseMag"].Value < 10)
{
row["baseMag"].Value = (sbyte)10;
}
if (cheat)
{
foreach (string stat in stats)
{
row[$"base{stat}"].Value = (sbyte)90;
}
}
// Then, see stat diffs for weapons/spells/catalysts, and fudge if necessary
CharacterClass chClass = classes[i];
int attStat = (sbyte)row["baseWil"].Value;
StatReq chReqs = new StatReq
{
Str = (sbyte)row["baseStr"].Value,
Dex = (sbyte)row["baseDex"].Value,
Mag = (sbyte)row["baseMag"].Value,
Fai = (sbyte)row["baseFai"].Value,
Att = (sbyte)(attStat < 10 ? 0 : attStat < 14 ? 1 : 2),
};
StatReq dynamicReqs = chReqs;
double fudgeFactor = 1.5;
float weaponWeight = 0f;
int attSlots = 0;
bool crossbowSelected = false;
Console.WriteLine($"Randomizing starting equipment for {chClass.Name}");
foreach (KeyValuePair <string, EquipCategory> entry in baseStart.Concat(chClass.Start))
{
EquipCategory cat = entry.Value;
// TODO: If a catalyst etc also doubles as a weapon, maybe skip its slot.
// This crossbow/bow logic relies on iteration order - try to make the order fixed...
if ((cat == EquipCategory.ARROW && crossbowSelected) || (cat == EquipCategory.BOLT && !crossbowSelected))
{
continue;
}
Dictionary <ItemKey, int> statDiffs = items[entry.Value].ToDictionary(item => item, item => requirements[item].Eligible(dynamicReqs));
List <ItemKey> candidates = items[entry.Value];
if (cat == EquipCategory.SHIELD || chClass.Name == "Deprived")
{
candidates = candidates.Where(item => statDiffs[item] >= 0).ToList();
}
if (cat == EquipCategory.SORCERY || cat == EquipCategory.MIRACLE || cat == EquipCategory.PYROMANCY)
{
// Fit within attunement slots. Alternatively could increase attunement, but that unbalances things potentially.
// Unfortunately means that pyromancer can't start with Chaos Bed Vestiges. Maybe for the best.
if (attSlots == chReqs.Att)
{
row[entry.Key].Value = -1;
continue;
}
candidates = candidates.Where(item => attSlots + requirements[item].Att <= chReqs.Att).ToList();
}
// Select weapon and adjust stats if necessary
List <ItemKey> weightKeys = WeightedShuffle(random, candidates, item =>
{
int diff = statDiffs[item];
if (diff >= 4)
{
return((float)Math.Pow(2, -4 * (Math.Min(diff, 20) / 20.0)));
}
if (diff >= 0)
{
return(2);
}
return((float)Math.Pow(fudgeFactor, diff));
});
ItemKey selected = weightKeys[0];
items[entry.Value].Remove(selected);
if (statDiffs[selected] < 0)
{
dynamicReqs.Adjust(requirements[selected]);
fudgeFactor *= -statDiffs[selected];
}
row[entry.Key].Value = selected.ID;
if (weights.ContainsKey(selected))
{
weaponWeight += weights[selected];
}
attSlots = requirements[selected].Att;
Console.WriteLine($" {entry.Key} is now {game.Name(selected)}, meets requirements by {statDiffs[selected]}");
}
int statChange = dynamicReqs.Eligible(chReqs);
if (statChange < 0)
{
row["baseStr"].Value = dynamicReqs.Str;
row["baseDex"].Value = dynamicReqs.Dex;
row["baseMag"].Value = dynamicReqs.Mag;
row["baseFai"].Value = dynamicReqs.Fai;
row["soulLvl"].Value = (short)((short)row["soulLvl"].Value - statChange);
}
// Armor time
float totalWeight = 40 + (sbyte)row["baseDurability"].Value;
List <ArmorSet> availableSets = armors.TakeWhile(armor => armor.Weight + weaponWeight < totalWeight * 0.69f).ToList();
if (availableSets.Count == 0)
{
availableSets = new List <ArmorSet> {
armors[0]
}
}
;
ArmorSet selectedArmor = Choice(random, availableSets);
armors.Remove(selectedArmor);
Console.WriteLine($" Armor: {string.Join(", ", selectedArmor.Ids.Select(id => game.Name(new ItemKey(ItemType.ARMOR, id))))}");
Console.WriteLine($" Weight: weapons {weaponWeight:0.##} + armor {selectedArmor.Weight:0.##} / {totalWeight:0.##} = {100*(weaponWeight+selectedArmor.Weight)/totalWeight:0.##}%");
for (int j = 0; j < 4; j++)
{
if ((int)row[armorSlots[j]].Value != -1)
{
row[armorSlots[j]].Value = selectedArmor.Ids[j];
}
}
if (cheat)
{
PARAM reinforce = game.Param("ReinforceParamWeapon");
HashSet <int> reinforceLevels = new HashSet <int>(reinforce.Rows.Select(r => (int)r.ID));
foreach (string wep in weaponSlots)
{
int id = (int)row[wep].Value;
if (id != -1)
{
id = id - (id % 100);
PARAM.Row item = game.Item(new ItemKey(ItemType.WEAPON, id));
int reinforceId = (short)item["reinforceTypeId"].Value;
while (reinforceLevels.Contains(reinforceId + 5))
{
reinforceId += 5;
id += 5;
}
row[wep].Value = id;
}
}
}
}
// Now, have fun with NPCs
Dictionary <string, ArmorSet> npcArmors = new Dictionary <string, ArmorSet>();
Func <ItemType, PARAM.Cell, float> cellWeight = (type, cell) =>
{
int id = (int)cell.Value;
if (id == -1)
{
return(0);
}
ItemKey key = new ItemKey(type, id);
if (!weights.ContainsKey(key))
{
return(0);
}
return(weights[key]);
};
foreach (PARAM.Row row in chara.Rows.Where(r => r.ID > startId + 10))
{
string name = game.CharacterName((int)row.ID);
if (name == "?CHARACTER?")
{
continue;
}
ArmorSet selectedArmor;
if (!npcArmors.ContainsKey(name))
{
float weaponWeight = weaponSlots.Select(slot => cellWeight(ItemType.WEAPON, row[slot])).Sum();
float armorWeight = armorSlots.Select(slot => cellWeight(ItemType.ARMOR, row[slot])).Sum();
float weightLimit = weaponWeight + armorWeight;
float totalWeight = 40 + (sbyte)row["baseDurability"].Value;
int armorLimit = armors.FindIndex(armor => armor.Weight + weaponWeight > weightLimit);
if (armorLimit == -1)
{
armorLimit = armors.Count - 1;
}
armorLimit = Math.Min(20, armorLimit);
selectedArmor = npcArmors[name] = armors[random.Next(armorLimit)];
armors.Remove(selectedArmor);
Console.WriteLine($"Armor for {name}: {100 * weightLimit / totalWeight:0.##}% -> {100 * (selectedArmor.Weight + weaponWeight) / totalWeight:0.##}%: {string.Join(", ", selectedArmor.Ids.Select(id => game.Name(new ItemKey(ItemType.ARMOR, id))))}");
}
selectedArmor = npcArmors[name];
for (int j = 0; j < 4; j++)
{
if ((int)row[armorSlots[j]].Value != -1)
{
row[armorSlots[j]].Value = selectedArmor.Ids[j];
}
}
}
}
}
public static void AddTieredRecipes(string setName)
{
ArmorSet armor = ArmorSets[setName];
string armorSetName = char.ToUpper(setName[0]) + setName.Substring(1);
for (int i = (int)balance[setName]["upgrades"]["startingTier"] + 1; i <= 5; i++)
{
Recipe helmetRecipe;
Recipe chestRecipe;
Recipe legsRecipe;
if (setName != "barbarian")
{
helmetRecipe = ObjectDB.instance.GetRecipe(ObjectDB.instance.GetItemPrefab($"{armor.HelmetID}T{i}_Terraheim_AddNewSets_Add{armorSetName}Armor").GetComponent <ItemDrop>().m_itemData);
chestRecipe = ObjectDB.instance.GetRecipe(ObjectDB.instance.GetItemPrefab($"{armor.ChestID}T{i}_Terraheim_AddNewSets_Add{armorSetName}Armor").GetComponent <ItemDrop>().m_itemData);
legsRecipe = ObjectDB.instance.GetRecipe(ObjectDB.instance.GetItemPrefab($"{armor.LegsID}T{i}_Terraheim_AddNewSets_Add{armorSetName}Armor").GetComponent <ItemDrop>().m_itemData);
}
else
{
helmetRecipe = ObjectDB.instance.GetRecipe(ObjectDB.instance.GetItemPrefab($"{armor.HelmetID}T{i}_Terraheim_BarbarianArmor_AddNewSets").GetComponent <ItemDrop>().m_itemData);
chestRecipe = ObjectDB.instance.GetRecipe(ObjectDB.instance.GetItemPrefab($"{armor.ChestID}T{i}_Terraheim_BarbarianArmor_AddNewSets").GetComponent <ItemDrop>().m_itemData);
legsRecipe = ObjectDB.instance.GetRecipe(ObjectDB.instance.GetItemPrefab($"{armor.LegsID}T{i}_Terraheim_BarbarianArmor_AddNewSets").GetComponent <ItemDrop>().m_itemData);
}
List <Piece.Requirement> helmetList = helmetRecipe.m_resources.ToList();
List <Piece.Requirement> chestList = chestRecipe.m_resources.ToList();
List <Piece.Requirement> legsList = legsRecipe.m_resources.ToList();
if (setName == "silver")
{
helmetList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab("HelmetDrake").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
chestList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab("ArmorWolfChest").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});;
legsList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab("ArmorWolfLegs").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
}
else if (setName == "barbarian")
{
helmetList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab($"{armor.HelmetID}T{i-1}_Terraheim_BarbarianArmor_AddNewSets").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
chestList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab($"{armor.ChestID}T{i-1}_Terraheim_BarbarianArmor_AddNewSets").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
legsList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab($"{armor.LegsID}T{i-1}_Terraheim_BarbarianArmor_AddNewSets").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
}
else
{
helmetList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab($"{armor.HelmetID}T{i - 1}_Terraheim_AddNewSets_Add{armorSetName}Armor").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
chestList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab($"{armor.ChestID}T{i - 1}_Terraheim_AddNewSets_Add{armorSetName}Armor").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
legsList.Add(new Piece.Requirement()
{
m_resItem = ObjectDB.instance.GetItemPrefab($"{armor.LegsID}T{i - 1}_Terraheim_AddNewSets_Add{armorSetName}Armor").GetComponent <ItemDrop>(),
m_amount = 1,
m_amountPerLevel = 0,
m_recover = false
});
}
helmetRecipe.m_resources = helmetList.ToArray();
chestRecipe.m_resources = chestList.ToArray();
legsRecipe.m_resources = legsList.ToArray();
}
}
public static void AddArmorPiece(string setName, string location)
{
var setBalance = balance[setName];
ArmorSet armor = ArmorSets[setName];
for (int i = (int)setBalance["upgrades"]["startingTier"]; i <= 5; i++)
{
var tierBalance = setBalance["upgrades"][$"t{i}"];
string id = "";
string name = "";
switch (location)
{
case "head":
id = armor.HelmetID;
name = armor.HelmetName;
break;
case "chest":
id = armor.ChestID;
name = armor.ChestName;
break;
case "legs":
id = armor.LegsID;
name = armor.LegsName;
break;
default:
break;
}
//Create mocks for use in clones
GameObject clonedPiece = PrefabManager.Instance.CreateClonedPrefab($"{id}T{i}", id);
//Set ID so that previous armors still exist
if (setName != "barbarian")
{
string armorSetName = char.ToUpper(setName[0]) + setName.Substring(1);
clonedPiece.name = $"{id}T{i}_Terraheim_AddNewSets_Add{armorSetName}Armor";
}
else
{
clonedPiece.name = $"{id}T{i}_Terraheim_BarbarianArmor_AddNewSets";
}
CustomItem piece = new CustomItem(clonedPiece, true);
piece.ItemDrop.m_itemData.m_shared.m_name = $"{name}{i}";
ModArmorPiece(setName, location, ref piece.ItemDrop.m_itemData, setBalance, true, i);
//Recipes
Recipe recipe = ScriptableObject.CreateInstance <Recipe>();
recipe.name = $"Recipe_{id}T{i}";
List <Piece.Requirement> recipeList = new List <Piece.Requirement>();
//Add base armor to requirements
int j = 0;
if (i == (int)setBalance["upgrades"]["startingTier"])
{
recipeList.Add(MockRequirement.Create(id, 1, false));
j++;
recipeList[0].m_amountPerLevel = 0;
}
var recipeReqs = balance["upgradePath"][$"t{i}"];
int index = 0 + j;
foreach (JObject item in recipeReqs[location])
{
recipeList.Add(MockRequirement.Create((string)item["item"], (int)item["amount"]));
recipeList[index].m_amountPerLevel = (int)item["perLevel"];
index++;
}
recipe.m_craftingStation = Mock <CraftingStation> .Create((string)recipeReqs["station"]);
//Set crafting station level
recipe.m_minStationLevel = (int)recipeReqs["minLevel"];
//Assign reqs to recipe
recipe.m_resources = recipeList.ToArray();
//Add item to recipe
recipe.m_item = piece.ItemDrop;
//Create the custome recipe
CustomRecipe customPieceRecipe = new CustomRecipe(recipe, fixReference: true, fixRequirementReferences: true);
ItemManager.Instance.AddItem(piece);
//Add recipes to DB
ItemManager.Instance.AddRecipe(customPieceRecipe);
}
}
public static void ModArmorSet(string setName, ref ItemDrop.ItemData helmet, ref ItemDrop.ItemData chest, ref ItemDrop.ItemData legs, JToken values, bool isNewSet, int i)
{
ArmorSet armor = ArmorSets[setName];
List <ItemDrop.ItemData> armorList = new List <ItemDrop.ItemData>()
{
helmet, chest, legs
};
JToken tierBalance;
if (isNewSet)
{
tierBalance = values["upgrades"][$"t{i}"];
}
else
{
tierBalance = values;
if (setName != "barbarian")
{
helmet.m_shared.m_name = $"{armor.HelmetName}0";
chest.m_shared.m_name = $"{armor.ChestName}0";
legs.m_shared.m_name = $"{armor.LegsName}0";
}
}
StatusEffect setEffect = GetSetEffect((string)values["setEffect"], tierBalance);
foreach (ItemDrop.ItemData item in armorList)
{
item.m_shared.m_armor = (float)tierBalance["baseArmor"];
item.m_shared.m_armorPerLevel = (float)tierBalance["armorPerLevel"];
if (setEffect != null)
{
item.m_shared.m_setStatusEffect = setEffect;
}
else
{
Log.LogWarning($"{setName} - No set effect found for provided effect: {(string)values["setEffect"]}");
}
item.m_shared.m_setSize = 3;
item.m_shared.m_setName = (string)values["name"];
if (!item.m_shared.m_name.Contains("helmet"))
{
item.m_shared.m_movementModifier = (float)tierBalance["globalMoveMod"];
}
item.m_shared.m_description = $"<i>{armor.ClassName}</i>\n{item.m_shared.m_description}";
}
helmet.m_shared.m_armor += armor.HelmetArmor;
StatusEffect headStatus = GetArmorEffect((string)values["headEffect"], tierBalance, "head", ref helmet.m_shared.m_description);
StatusEffect chestStatus = GetArmorEffect((string)values["chestEffect"], tierBalance, "chest", ref chest.m_shared.m_description);
StatusEffect legStatus = GetArmorEffect((string)values["legsEffect"], tierBalance, "legs", ref legs.m_shared.m_description);
if ((string)values["headEffect"] == "challengemvespd")
{
helmet.m_shared.m_movementModifier += (float)values[$"headEffectVal"];
}
if ((string)values["chestEffect"] == "challengemvespd")
{
chest.m_shared.m_movementModifier += (float)values[$"chestEffectVal"];
}
if ((string)values["legsEffect"] == "challengemvespd")
{
legs.m_shared.m_movementModifier += (float)values[$"legsEffectVal"];
}
if (headStatus != null)
{
helmet.m_shared.m_equipStatusEffect = headStatus;
}
else
{
Log.LogWarning($"{setName} Head - No status effect found for provided effect: {(string)values["headEffect"]}");
}
if (chestStatus != null)
{
chest.m_shared.m_equipStatusEffect = chestStatus;
}
else
{
Log.LogWarning($"{setName} Chest - No status effect found for provided effect: {(string)values["chestEffect"]}");
}
if (legStatus != null)
{
legs.m_shared.m_equipStatusEffect = legStatus;
}
else
{
Log.LogWarning($"{setName} Legs - No status effect found for provided effect: {(string)values["legsEffect"]}");
}
}
private void ParseObject(object o)
{
string s;
Dictionary <string, FieldInfo> fields = new Dictionary <string, FieldInfo>();
//get all class variables
foreach (var prop in o.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
fields.Add(prop.Name, prop);
}
do
{
ParseLine();
s = getString();
if (o.GetType() == typeof(LoadSubsystem))
{
LoadSubsystem ls = (LoadSubsystem)o;
switch (s)
{
case "InitFile":
ls.AddInitFile(getString());
break;
case "InitFileDebug":
ls.AddInitFileDebug(getString());
break;
case "InitPath":
ls.AddInitPath(getString());
break;
case "IncludePathCinematics":
ls.AddIncludePathCinematics(getString());
break;
case "ExcludePath":
ls.AddExcludePath(getString());
break;
}
}
else if (o.GetType() == typeof(AnimationState))
{
AnimationState state = (AnimationState)o;
string name;
switch (s)
{
case "Animation":
Animation anim = new Animation();
ParseObject(anim);
state.AddAnimation(anim);
break;
case "BeginScript":
string line = getLine();
while (!line.Equals("EndScript"))
{
state.AddScriptLine(line);
line = getLine();
}
break;
case "ParticleSysBone":
name = getString();
state.AddParticleSysBone(name, ParseParticleSysBone());
break;
}
}
else if (o.GetType() == typeof(Armor))
{
Armor ar = (Armor)o;
switch (s)
{
case "Armor":
ar.AddType(getString(), getFloat());
break;
}
}
else if (o.GetType() == typeof(AudioEvent))
{
AudioEvent ae = (AudioEvent)o;
switch (s)
{
case "Sounds":
string val = getStrings();
string[] sounds = val.Split(' ');
foreach (string sound in sounds)
{
MusicTrack mt;
if (INIManager.TryGetMusicTrack(sound, out mt))
{
ae.AddMusicTrack(mt);
}
//else
// PrintError(" no such MusicTrack found: " + sound);
}
break;
}
}
else if (o.GetType() == typeof(Draw))
{
Draw dr = (Draw)o;
string name;
switch (s)
{
case "AnimationState":
AnimationState astate = new AnimationState();
name = getString();
ParseObject(astate);
dr.AddAnimationState(name, astate);
break;
case "DefaultModelConditionState":
ModelConditionState defMod = new ModelConditionState();
ParseObject(defMod);
dr.DefaultModelConditionState = defMod;
break;
case "IdleAnimationState":
AnimationState iastate = new AnimationState();
ParseObject(iastate);
dr.IdleAnimationState = iastate;
break;
case "ModelConditionState":
ModelConditionState mcs = new ModelConditionState();
name = getString();
ParseObject(mcs);
dr.AddModelConditionState(name, mcs);
break;
}
}
else if (o.GetType() == typeof(FXList))
{
FXList fx = (FXList)o;
switch (s)
{
case "BuffNugget":
BuffNugget bn = new BuffNugget();
ParseObject(bn);
fx.buffNugget = bn;
break;
case "CameraShakerVolume":
CameraShakerVolume cs = new CameraShakerVolume();
ParseObject(cs);
fx.cameraShakerVolume = cs;
break;
case "DynamicDecal":
DynamicDecal dc = new DynamicDecal();
ParseObject(dc);
fx.AddDynamicDecal(dc);
break;
case "ParticleSystem":
ParticleSystem ps = new ParticleSystem();
ParseObject(ps);
fx.AddParticleSystem(ps);
break;
case "Sound":
Sound so = new Sound();
ParseObject(so);
fx.AddSound(so);
break;
case "TerrainScorch":
TerrainScorch ts = new TerrainScorch();
ParseObject(ts);
fx.AddTerrainScorch(ts);
break;
case "TintDrawable":
TintDrawable td = new TintDrawable();
ParseObject(td);
fx.tintDrawable = td;
break;
case "ViewShake":
ViewShake vs = new ViewShake();
ParseObject(vs);
fx.viewShake = vs;
break;
}
}
else if (o.GetType() == typeof(GameData))
{
GameData gd = (GameData)o;
switch (s)
{
case "StandardPublicBone":
gd.AddStandardPublicBone(getString());
break;
case "WeaponBonus":
gd.AddWeaponBonus(getString(), getString(), getInt());
break;
}
}
else if (o.GetType() == typeof(ModelConditionState))
{
ModelConditionState mstate = (ModelConditionState)o;
string name;
switch (s)
{
case "ParticleSysBone":
name = getString();
mstate.AddParticleSysBone(name, ParseParticleSysBone());
break;
}
}
else if (o.GetType() == typeof(ModifierList))
{
ModifierList ml = (ModifierList)o;
switch (s)
{
case "Modifier":
ml.AddModifier(getString(), getStrings());
break;
}
}
else if (o.GetType() == typeof(Multisound))
{
Multisound ms = (Multisound)o;
switch (s)
{
case "Subsounds":
string val = getStrings();
string[] sounds = val.Split(' ');
foreach (string sound in sounds)
{
MusicTrack mt;
if (INIManager.TryGetMusicTrack(sound, out mt))
{
ms.AddMusicTrack(mt);
}
//else
// PrintError(" no such MusicTrack found: " + sound);
}
break;
}
}
else if (o.GetType() == typeof(INI.Object))
{
INI.Object obj = (INI.Object)o;
string name;
switch (s)
{
case "ArmorSet":
ArmorSet set = new ArmorSet();
ParseObject(set);
obj.AddArmorSet(set);
break;
case "Behaviour":
Behaviour b = new Behaviour();
name = getString();
ParseObject(b);
obj.AddBehaviour(name, b);
break;
case "Body":
Body bo = new Body();
name = getString();
ParseObject(bo);
obj.AddBody(name, bo);
break;
case "Draw":
Draw d = new Draw();
name = getString();
ParseObject(d);
obj.AddDraw(name, d);
break;
}
}
else if (o.GetType() == typeof(Weapon))
{
Weapon w = (Weapon)o;
switch (s)
{
case "AttributeModifierNugget":
AttributeModifierNugget amn = new AttributeModifierNugget();
ParseObject(amn);
w.attributeModifierNugget = amn;
break;
case "DamageContainedNugget":
DamageContainedNugget dcn = new DamageContainedNugget();
ParseObject(dcn);
w.damageContainedNugget = dcn;
break;
case "DamageFieldNugget":
DamageFieldNugget dfn = new DamageFieldNugget();
ParseObject(dfn);
w.damageFieldNugget = dfn;
break;
case "DamageNugget":
DamageNugget dn = new DamageNugget();
ParseObject(dn);
w.damageNugget = dn;
break;
case "DOTNugget":
DOTNugget don = new DOTNugget();
ParseObject(don);
w.dotNugget = don;
break;
case "FireLogicNugget":
FireLogicNugget fln = new FireLogicNugget();
ParseObject(fln);
w.fireLogicNugget = fln;
break;
case "HordeAttackNugget":
HordeAttackNugget han = new HordeAttackNugget();
ParseObject(han);
w.hordeAttackNugget = han;
break;
case "LuaEventNugget":
LuaEventNugget len = new LuaEventNugget();
ParseObject(len);
w.luaEventNugget = len;
break;
case "MetaImpactNugget":
MetaImpactNugget min = new MetaImpactNugget();
ParseObject(min);
w.metaImpactNugget = min;
break;
case "OpenGateNugget":
OpenGateNugget ogn = new OpenGateNugget();
ParseObject(ogn);
w.openGateNugget = ogn;
break;
case "ParalyzeNugget":
ParalyzeNugget pan = new ParalyzeNugget();
ParseObject(pan);
w.paralyzeNugget = pan;
break;
case "ProjectileNugget":
ProjectileNugget pn = new ProjectileNugget();
ParseObject(pn);
w.AddProjectileNugget(pn);
break;
case "SlaveAttackNugget":
SlaveAttackNugget san = new SlaveAttackNugget();
ParseObject(san);
w.slaveAttackNugget = san;
break;
case "StealMoneyNugget":
StealMoneyNugget smn = new StealMoneyNugget();
ParseObject(smn);
w.stealMoneyNugget = smn;
break;
case "WeaponOCLNugget":
WeaponOCLNugget won = new WeaponOCLNugget();
ParseObject(won);
w.weaponOCLNugget = won;
break;
}
}
else if (fields.ContainsKey(s))
{
Type type = fields[s].FieldType;
if (type == typeof(string))
{
fields[s].SetValue(o, getString());
}
else if (type == typeof(int))
{
fields[s].SetValue(o, getInt());
}
else if (type == typeof(int[]))
{
fields[s].SetValue(o, getInts());
}
else if (type == typeof(float))
{
fields[s].SetValue(o, getFloat());
}
else if (type == typeof(float[]))
{
fields[s].SetValue(o, getFloats());
}
else if (type == typeof(bool))
{
fields[s].SetValue(o, getBool());
}
else if (type == typeof(OpenTK.Vector2))
{
fields[s].SetValue(o, getVec2());
}
else if (type == typeof(OpenTK.Vector3))
{
fields[s].SetValue(o, getVec3());
}
else
{
PrintError("invalid type: " + type);
}
}
else
{
if (!s.Equals("End") && !s.Equals("END"))
{
PrintError("invalid parameter in " + o.GetType() + " class: " + s);
}
}
}while (!s.Equals("End") && !s.Equals("END"));
}
public static bool Parse(ref Tokenizer tokenizer, out ArmorSet answer)
{
answer = new ArmorSet();
if (!tokenizer.Expect(TokenName.OPEN_PARENTHESIS))
{
return(false);
}
do
{
Instruction instruction = ReadInstruction(ref tokenizer);
switch (instruction)
{
case Instruction.GEAR:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.gear))
{
return(false);
}
answer.weapon_slots = answer.gear.id;
break;
case Instruction.HEAD:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.head))
{
return(false);
}
break;
case Instruction.BODY:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.body))
{
return(false);
}
break;
case Instruction.ARMS:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.arms))
{
return(false);
}
break;
case Instruction.WAIST:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.waist))
{
return(false);
}
break;
case Instruction.LEGS:
if (!ArmorSetPiece.Parse(ref tokenizer, out answer.legs))
{
return(false);
}
break;
case Instruction.AMULET:
if (!Amulet.Parse(ref tokenizer, out answer.amulet))
{
return(false);
}
break;
case Instruction.COMPLETE:
return(true);
default:
return(false);
}
} while (!tokenizer.Empty());
return(false);
}
private async Task LoadArmorsData(ILogger logger)
{
Task <IList <ArmorPiecePrimitive> > armorTask = LoadBase <ArmorPiecePrimitive>("armor", logger);
Task <IList <ArmorSetPrimitive> > setsTask = LoadBase <ArmorSetPrimitive>("armor/sets", logger);
await Task.WhenAll(armorTask, setsTask);
IList <ArmorPiecePrimitive> armorResult = armorTask.Result;
IList <ArmorSetPrimitive> setsResult = setsTask.Result;
if (armorResult == null || setsResult == null)
{
return;
}
var allArmors = new IArmorPiece[armorResult.Count];
for (int i = 0; i < allArmors.Length; i++)
{
var localAbilities = new IAbility[armorResult[i].Abilities.Count];
for (int j = 0; j < localAbilities.Length; j++)
{
int skillId = armorResult[i].Abilities[j].SkillId;
int abilityLevel = armorResult[i].Abilities[j].Level;
ISkill skill = skills.FirstOrDefault(s => s.Id == skillId);
IAbility ability = abilities.FirstOrDefault(a => a.Skill.Id == skillId && a.Level == abilityLevel);
localAbilities[j] = new Ability(skill, abilityLevel, ability.Description);
}
allArmors[i] = new DataStructures.ArmorPiece(armorResult[i], localAbilities);
}
foreach (ArmorSetPrimitive armorSetPrimitive in setsResult)
{
var setArmorPieces = new IArmorPiece[armorSetPrimitive.ArmorPieces.Length];
for (int i = 0; i < armorSetPrimitive.ArmorPieces.Length; i++)
{
setArmorPieces[i] = allArmors.FirstOrDefault(x => x.Id == armorSetPrimitive.ArmorPieces[i].ArmorPieceId);
}
List <IArmorSetSkill> armorSetSkills = null;
if (armorSetPrimitive.Bonus != null)
{
armorSetSkills = new List <IArmorSetSkill>();
foreach (ArmorSetBonusRankPrimitive bonusRank in armorSetPrimitive.Bonus.Ranks)
{
IAbility[] setAbilities = abilities.Where(a => a.Skill.Id == bonusRank.Skill.SkillId && a.Level == bonusRank.Skill.Level).ToArray();
armorSetSkills.Add(new ArmorSetSkill(bonusRank.PieceCount, setAbilities));
}
}
var armorSet = new ArmorSet(armorSetPrimitive.Id, false, setArmorPieces, armorSetSkills?.ToArray());
foreach (DataStructures.ArmorPiece armorPiece in setArmorPieces)
{
armorPiece.UpdateArmorSet(armorSet);
}
}
armors = allArmors;
}
