// Token: 0x06000025 RID: 37 RVA: 0x00003C6C File Offset: 0x00001E6C
public static float AmpDamage(Character character, float damage, DamageType.Types type)
{
DamageList damageList = new DamageList(type, damage);
character.Stats.GetAmplifiedDamage(null, ref damageList);
return(damageList.TotalDamage);
}
static SL_EnchantmentRecipe CreateDamageEnchantment(int id, string name, DamageType.Types type)
{
return(new SL_EnchantmentRecipe
{
EnchantmentID = id + TsarPlus.ENCHANTMENT_OFFSET + TsarPlus.ID_OFFSET,
Name = name,
CompatibleEquipment = new SL_EnchantmentRecipe.EquipmentData()
{
RequiredTag = "Item"
},
FlatDamageAdded = new SL_Damage[]
{
new SL_Damage()
{
Damage = 5,
Type = type
},
},
DamageResistanceBonus = new SL_Damage[0],
DamageModifierBonus = new SL_Damage[0],
StatModifications = new SL_EnchantmentRecipe.StatModification[0],
AddedDamages = new SL_EnchantmentRecipe.AdditionalDamage[0],
Effects = new SL_EffectTransform[0],
PillarDatas = new SL_EnchantmentRecipe.PillarData[0],
Areas = new AreaManager.AreaEnum[0],
WeatherConditions = new SL_EnchantmentRecipe.WeatherCondition[0],
Temperature = new TemperatureSteps[0],
TimeOfDay = new UnityEngine.Vector2[0]
});
}
public static void AddWeaponDamage(Item item, DamageType.Types weaponDamageType, float damageAmount)
{
WeaponStats weaponStatComponent = item.GetComponent <WeaponStats>();
DamageType damageType = new DamageType(weaponDamageType, damageAmount);
weaponStatComponent.BaseDamage.Add(damageType);
AddAttackStepDamageType(weaponStatComponent.Attacks, damageAmount, weaponDamageType);
}
public float GetDamageMultiplier(DamageType.Types type)
{
float multiplier = 1.0f;
if (MainWeapon.DamageBonus != null)
{
multiplier += MainWeapon.DamageBonus[(int)type];
}
if (!MainWeapon.TwoHanded && Offhand.DamageBonus != null)
{
multiplier += Offhand.DamageBonus[(int)type];
}
if (Helmet.DamageBonus != null)
{
multiplier += Helmet.DamageBonus[(int)type];
}
if (Chest.DamageBonus != null)
{
multiplier += Chest.DamageBonus[(int)type];
}
if (Boots.DamageBonus != null)
{
multiplier += Boots.DamageBonus[(int)type];
}
if (Backpack.DamageBonus != null)
{
multiplier += Backpack.DamageBonus[(int)type];
}
if (Statuses != null)
{
foreach (var status in Statuses)
{
multiplier += status.DamageBonus[(int)type] + status.AllDamageBonus;
}
}
if (Passives != null)
{
foreach (var passive in Passives)
{
multiplier += passive.DamageBonus[(int)type] + passive.AllDamageBonus;
}
}
return(multiplier);
}
public override void SerializeEffect <T>(T effect)
{
base.SerializeEffect(effect);
var weaponDamage = effect as WeaponDamage;
ForceOnlyLeftHand = weaponDamage.ForceOnlyLeftHand;
OverrideType = weaponDamage.OverrideDType;
Damage_Multiplier = weaponDamage.WeaponDamageMult;
Damage_Multiplier_Kback = weaponDamage.WeaponDamageMultKBack;
Damage_Multiplier_Kdown = weaponDamage.WeaponDamageMultKDown;
Impact_Multiplier = weaponDamage.WeaponKnockbackMult;
Impact_Multiplier_Kback = weaponDamage.WeaponKnockbackMultKBack;
Impact_Multiplier_Kdown = weaponDamage.WeaponKnockbackMultKDown;
}
// Token: 0x06000040 RID: 64 RVA: 0x00004884 File Offset: 0x00002A84
public static float AmpDamage(Character character, float damage, DamageType.Types type)
{
bool flag = type == DamageType.Types.Count;
float result;
if (flag)
{
result = damage;
}
else
{
DamageList damageList = new DamageList(type, damage);
character.Stats.GetAmplifiedDamage(null, ref damageList);
result = damageList.TotalDamage;
}
return(result);
}
public void ReInitaliseWeapons(Item item, JSONArray itemMods)
{
Debug.Log("Reinit Armour Item " + item.Name);
if (item != null)
{
Debug.Log("Reinit Armour Item " + item.Name);
EquipmentStats itemEquipStats = item.GetComponent <EquipmentStats>();
foreach (var thisModification in itemMods)
{
var modifyVar = thisModification.Value["mod_var"];
var modifyValue = thisModification.Value["mod_value"];
var modifyVarType = (WeaponModType)Enum.Parse(typeof(WeaponModType), thisModification.Value["mod_value_type"], true);
Debug.Log(modifyVarType);
switch (modifyVarType)
{
case WeaponModType.DAMAGE:
DamageType.Types type = (DamageType.Types)Enum.Parse(typeof(DamageType.Types), thisModification.Value["mod_var"], true);
WeaponHelper.AddWeaponDamage(item, type, modifyValue);
break;
case WeaponModType.IMPACT:
WeaponHelper.UpdateImpact(item, modifyValue);
break;
case WeaponModType.DURABILITY:
WeaponHelper.UpdateDurability(item, modifyValue);
break;
case WeaponModType.SPEED:
WeaponHelper.UpdateAttackSpeed(item, modifyValue);
break;
case WeaponModType.REACH:
WeaponHelper.UpdateAttackReach(item, modifyValue);
break;
}
}
}
}
public ImbueModel(ImbueEffectPreset preset)
{
Name = preset.Name.Trim();
PresetID = preset.PresetID;
DamageMultiplier = 0f;
OverrideType = DamageType.Types.Count;
BonusDamage = new DamageList();
AttackSpeedModifier = 0;
if (preset.PresetID == 209)
{
AttackSpeedModifier = 0.2f;
}
else
{
if (preset.GetComponentInChildren <WeaponDamage>() is WeaponDamage weaponDamage)
{
OverrideType = weaponDamage.OverrideDType;
DamageMultiplier = weaponDamage.WeaponDamageMult - 1;
BonusDamage = new DamageList(weaponDamage.Damages);
}
}
}
public static Color GetDmgColor(DamageType.Types dtype)
{
Color color;
switch (dtype)
{
case DamageType.Types.Physical:
color = Global.WHITE_GRAY;
break;
case DamageType.Types.Ethereal:
color = Color.magenta;
break;
case DamageType.Types.Decay:
color = Global.LIGHT_GREEN;
break;
case DamageType.Types.Electric:
color = Color.yellow;
break;
case DamageType.Types.Frost:
color = Global.BLUE;
break;
case DamageType.Types.Fire:
color = lightRed;
break;
case DamageType.Types.Raw:
default:
color = Color.white;
break;
}
return(color);
}
public static void Postfix(CharacterEquipment __instance, ref float __result, ref DamageType.Types _type)
{
Character character = At.GetValue(typeof(CharacterEquipment), __instance, "m_character") as Character;
bool flag = character != null;
if (flag)
{
bool flag2 = (SkillRequirements.CanAddProtectionToPhysicalResistance(character) && _type == DamageType.Types.Physical) || SkillRequirements.CanAddProtectionToAnyDamageResistance(character);
if (flag2)
{
__result += __instance.GetEquipmentDamageProtection(DamageType.Types.Physical);
}
}
}
public ElementVanillaStat(SafeField <EquipmentStats, float[]> info, DamageType.Types type, String id, int place, VanillaStat.Type stattype) : base(id, place, stattype)
{
this.info = info;
this.type = type;
}
// Token: 0x06000021 RID: 33 RVA: 0x00003AD0 File Offset: 0x00001CD0
public static void StaticActivate(Effect instance, Character _affectedCharacter, object[] _infos, float _range, float _restoredHealth, DamageType.Types _amplificationType, bool _canRevive)
{
List <Character> list = new List <Character>();
CharacterManager.Instance.FindCharactersInRange(_affectedCharacter.CenterPosition, _range, ref list);
list = (from c in list
where c.Faction == _affectedCharacter.Faction
select c).ToList <Character>();
float quantity = HealingAoE.AmpHealing(_affectedCharacter, _restoredHealth, _amplificationType);
foreach (Character character in list)
{
bool flag = character.IsDead && _canRevive;
if (flag)
{
HealingAoE.Revive(character);
}
bool flag2 = !character.IsDead || _canRevive;
if (flag2)
{
character.Stats.AffectHealth(quantity);
}
}
}
public ElelWepDmgPrefix(DamageType.Types type, string name)
{
this.type = type;
this.name = name;
}
internal void SetUIDamageType(DamageType.Types type) => m_typeDropdown.value = (int)type;
static bool Prefix(ItemDetailsDisplay __instance)
{
int _index = 0;
if ((bool)(UnityEngine.Object)__instance.m_lastItem && __instance.m_lastItem.IsEnchanted && __instance.m_lastItem is Equipment lastItem)
{
for (int i = 0; i < lastItem.ActiveEnchantments.Count; ++i)
{
Enchantment activeEnchantment = lastItem.ActiveEnchantments[i];
if (lastItem is Weapon weapon && (activeEnchantment.PresetID == 3 || activeEnchantment.PresetID == 4))
{
int num1;
switch (weapon.Type)
{
case Weapon.WeaponType.Dagger_OH:
num1 = VampiricTransmutationTable.DAGGER_THIRST_THRESHOLD;
break;
case Weapon.WeaponType.Bow:
num1 = VampiricTransmutationTable.BOW_THIRST_THRESHOLD;
break;
default:
num1 = VampiricTransmutationTable.DEFAULT_THIRST_THRESHOLD;
break;
}
float num2 = (float)weapon.DamageDealtTracking / (float)num1;
if ((double)num2 >= 0.0 && (double)num2 < 0.330000013113022)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_01"), "");
++_index;
}
else if ((double)num2 >= 0.330000013113022 && (double)num2 < 0.660000026226044)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_02"), "");
++_index;
}
else if ((double)num2 >= 0.660000026226044 && (double)num2 < 1.0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_03"), "");
++_index;
}
else if ((double)num2 >= 1.0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("Vampiric_04"), "");
++_index;
}
if (MenuManager.Instance.DisplayDebugInfo)
{
__instance.GetEnchantmentRow(_index).SetInfo("DEBUG Damage", (float)weapon.DamageDealtTracking);
++_index;
}
}
DamageList _damages1 = new DamageList();
for (int index = 0; index < activeEnchantment.Effects.Length; ++index)
{
if (activeEnchantment.Effects[index] is AddStatusEffectBuildUp effect)
{
string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_InflictStatus", string.Empty);
__instance.GetEnchantmentRow(_index).SetInfo(loc, effect.Status.StatusName);
++_index;
}
else if (activeEnchantment.Effects[index] is AffectStatusEffectBuildUpResistance effect1)
{
string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_StatusResist", effect1.StatusEffect.StatusName);
__instance.GetEnchantmentRow(_index).SetInfo(loc, effect1.Value.ToString() + "%");
++_index;
}
else if (activeEnchantment.Effects[index] is ShootEnchantmentBlast effect2 && lastItem is Weapon weapon1)
{
DamageType.Types overrideDtype = effect2.BaseBlast.GetComponentInChildren <WeaponDamage>().OverrideDType;
float _damage = weapon1.GetDisplayedDamage().TotalDamage *effect2.DamageMultiplier;
_damages1.Add(new DamageType(overrideDtype, _damage));
}
}
if (_damages1.Count > 0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("EnchantmentDescription_Blast"), _damages1);
++_index;
}
DamageList _damages2 = new DamageList();
if (lastItem is Weapon weapon2)
{
_damages2 = weapon2.GetEnchantmentDamageBonuses();
}
if (_damages2.Count > 0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Damage"), _damages2);
++_index;
}
if (activeEnchantment.DamageModifier.Count != 0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_DamageModifier"), activeEnchantment.DamageModifier, _displayPercent: true);
++_index;
}
if (activeEnchantment.ElementalResistances.Count != 0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_DamageResistance"), activeEnchantment.ElementalResistances);
++_index;
}
if ((double)activeEnchantment.GlobalStatusResistance != 0.0)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_StatusResist"), activeEnchantment.GlobalStatusResistance);
++_index;
}
if ((double)activeEnchantment.ManaAbsorbRatio != 0.0)
{
string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_Absorb", activeEnchantment.ManaAbsorbRatio.ToString(), LocalizationManager.Instance.GetLoc("CharacterStat_Mana"));
__instance.GetEnchantmentRow(_index).SetInfo(loc, "");
++_index;
}
if ((double)activeEnchantment.HealthAbsorbRatio != 0.0)
{
string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_Absorb", activeEnchantment.HealthAbsorbRatio.ToString(), LocalizationManager.Instance.GetLoc("CharacterStat_Health"));
__instance.GetEnchantmentRow(_index).SetInfo(loc, "");
++_index;
}
if ((double)activeEnchantment.StaminaAbsorbRatio != 0.0)
{
string loc = LocalizationManager.Instance.GetLoc("EnchantmentDescription_Absorb", activeEnchantment.StaminaAbsorbRatio.ToString(), LocalizationManager.Instance.GetLoc("CharacterStat_Stamina"));
__instance.GetEnchantmentRow(_index).SetInfo(loc, "");
++_index;
}
for (int index = 0; index < activeEnchantment.StatModifications.Count; ++index)
{
float num = activeEnchantment.StatModifications[index].Value;
if (activeEnchantment.StatModifications[index].Name == Enchantment.Stat.CooldownReduction)
{
num = -num;
}
string _dataValue = ((double)num > 0.0 ? "+" : "") + num.ToString();
if (activeEnchantment.StatModifications[index].Type == Enchantment.StatModification.BonusType.Modifier)
{
_dataValue += "%";
}
switch (activeEnchantment.StatModifications[index].Name)
{
case Enchantment.Stat.Weight:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Weight"), _dataValue);
++_index;
break;
case Enchantment.Stat.Durability:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Durability"), _dataValue);
++_index;
break;
case Enchantment.Stat.ManaCostReduction:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_ManaCost"), _dataValue.Replace("+", "-"));
++_index;
break;
case Enchantment.Stat.StaminaCostReduction:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_StaminaCost"), _dataValue.Replace("+", "-"));
++_index;
break;
case Enchantment.Stat.CooldownReduction:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_CooldownReduction"), _dataValue);
++_index;
break;
case Enchantment.Stat.MovementSpeed:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_MovementPenalty"), _dataValue);
++_index;
break;
case Enchantment.Stat.AttackSpeed:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_AttackSpeed"), _dataValue);
++_index;
break;
case Enchantment.Stat.Impact:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Impact"), _dataValue);
++_index;
break;
case Enchantment.Stat.StabilityRegen:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_StabilityRegen"), _dataValue);
++_index;
break;
case Enchantment.Stat.HealthRegen:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_HealthRegen"), _dataValue);
++_index;
break;
case Enchantment.Stat.ManaRegen:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_ManaRegen"), _dataValue);
++_index;
break;
case Enchantment.Stat.Protection:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_Defense_Protection"), _dataValue);
++_index;
break;
case Enchantment.Stat.CorruptionResistance:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_CorruptionResistance"), _dataValue);
++_index;
break;
case Enchantment.Stat.FoodDepletionRate:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_FoodEfficiency"), _dataValue);
++_index;
break;
case Enchantment.Stat.DrinkDepletionRate:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_DrinkEfficiency"), _dataValue);
++_index;
break;
case Enchantment.Stat.SleepDepletionRate:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_SleepEfficiency"), _dataValue);
++_index;
break;
case Enchantment.Stat.PouchCapacity:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_PouchCapacity"), _dataValue);
++_index;
break;
case Enchantment.Stat.ImpactResistance:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("CharacterStat_Defense_ImpactResistance"), _dataValue);
++_index;
break;
case Enchantment.Stat.HeatProtection:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_HeatProtection"), _dataValue);
++_index;
break;
case Enchantment.Stat.ColdProtection:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_ColdProtection"), _dataValue);
++_index;
break;
case Enchantment.Stat.Barrier:
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("ItemStat_Barrier"), _dataValue);
++_index;
break;
}
}
if (activeEnchantment.Indestructible)
{
__instance.GetEnchantmentRow(_index).SetInfo(LocalizationManager.Instance.GetLoc("EnchantmentDescription_Indestructible"), "");
++_index;
}
}
}
for (int index = _index; index < __instance.m_enchantmentDetailRows.Count; ++index)
{
if (__instance.m_enchantmentDetailRows[index].IsDisplayed)
{
__instance.m_enchantmentDetailRows[index].Hide();
}
}
return(false);
}
public static void UpdateAttackStepDamage(WeaponStats.AttackData[] attackData, float damageValue, DamageType.Types damageType)
{
Debug.Log("Udapting Attack Step Damage for each step. (" + damageType.ToString() + ")");
var damageTypeAsInt = (int)damageType;
//iterate each attack step in attack data
for (int i = 0; i < attackData.Length; i++)
{
//Only update the damage for the given type
var currentAttackStep = attackData[i];
var oldValue = currentAttackStep.Damage[damageTypeAsInt];
var newValue = oldValue + damageValue;
Debug.Log("From " + oldValue + " To " + newValue);
currentAttackStep.Damage[damageTypeAsInt] = newValue;
}
}
public static void AddAttackStepDamageType(WeaponStats.AttackData[] attackData, float damageValue, DamageType.Types damageType)
{
Debug.Log("Setting Attack Step Damage for each step.");
Debug.Log("To " + damageValue);
var damageTypeAsInt = (int)damageType;
//iterate each attack step in attack data
for (int i = 0; i < attackData.Length; i++)
{
//Only update the damage for the given type
var currentAttackStep = attackData[i];
currentAttackStep.Damage.Add(damageValue);
}
}
public static IEnumerable <EquipmentModel> GetDamageBonusEquipment(SlotID equipType, DamageType.Types dmgType)
{
if (!s_cachedDmgBonusLists.ContainsKey(equipType))
{
List <EquipmentModel> fullList = null;
switch (equipType)
{
case SlotID.LeftHand:
fullList = OffhandModels; break;
case SlotID.Helmet:
fullList = HelmetModels; break;
case SlotID.Chest:
fullList = ChestModels; break;
case SlotID.Foot:
fullList = BootsModels; break;
case SlotID.Back:
fullList = BackpackModels; break;
}
s_cachedDmgBonusLists.Add(equipType, new Dictionary <DamageType.Types, List <EquipmentModel> >());
foreach (var opt in fullList)
{
if (HasAnyDamageBonus(opt, out List <DamageType.Types> typeList))
{
foreach (var type in typeList)
{
if (!s_cachedDmgBonusLists[equipType].ContainsKey(type))
{
s_cachedDmgBonusLists[equipType].Add(type, new List <EquipmentModel>());
}
s_cachedDmgBonusLists[equipType][type].Add(opt);
}
}
}
}
if (!s_cachedDmgBonusLists[equipType].ContainsKey(dmgType))
{
return(Enumerable.Empty <EquipmentModel>());
}
return(s_cachedDmgBonusLists[equipType][dmgType]);
}
public WeaponVanillaStat(DamageType.Types type, String id, int place, VanillaStat.Type stattype) : base(id, place, stattype)
{
this.type = type;
}
public void Init(DamageType.Types type)
{
this.Type = type;
}
public OfEleDmgRare(DamageType.Types type, string name)
{
this.type = type;
this.name = name;
}
// Token: 0x06000020 RID: 32 RVA: 0x00002A90 File Offset: 0x00000C90
public static ImbueEffectPreset MakeImbuePreset(int imbueID, string name, string description, string iconFileName, int visualEffectID, float flatDamage, float scalingDamage, DamageType.Types damageType, string statusEffect, Skill skill, int chanceToContract = 0, int buildUp = 0)
{
Dictionary <int, EffectPreset> dictionary = (Dictionary <int, EffectPreset>)At.GetValue(typeof(ResourcesPrefabManager), null, "EFFECTPRESET_PREFABS");
bool flag = !dictionary.ContainsKey(imbueID);
ImbueEffectPreset result;
if (flag)
{
GameObject gameObject = new GameObject(imbueID.ToString() + "_" + name.Replace(" ", ""));
gameObject.SetActive(true);
UnityEngine.Object.DontDestroyOnLoad(gameObject);
ImbueEffectPreset imbueEffectPreset = gameObject.AddComponent <ImbueEffectPreset>();
imbueEffectPreset.name = imbueID.ToString() + "_" + name.Replace(" ", "");
At.SetValue <int>(imbueID, typeof(EffectPreset), imbueEffectPreset, "m_StatusEffectID");
At.SetValue <string>(name, typeof(ImbueEffectPreset), imbueEffectPreset, "m_imbueNameKey");
At.SetValue <string>(description, typeof(ImbueEffectPreset), imbueEffectPreset, "m_imbueDescKey");
imbueEffectPreset.ImbueStatusIcon = ((ImbueEffectPreset)dictionary[visualEffectID]).ImbueStatusIcon;
imbueEffectPreset.ImbueFX = ((ImbueEffectPreset)dictionary[visualEffectID]).ImbueFX;
TinyEffectManager.SetNameAndDesc(imbueEffectPreset, name, description);
dictionary.Add(imbueID, imbueEffectPreset);
GameObject gameObject2 = new GameObject("Effects");
gameObject2.SetActive(true);
UnityEngine.Object.DontDestroyOnLoad(gameObject2);
gameObject2.transform.SetParent(imbueEffectPreset.transform);
bool flag2 = statusEffect != null && chanceToContract > 0;
if (flag2)
{
TinyEffectManager.AddStatusEffectChance(imbueEffectPreset, chanceToContract, statusEffect);
}
bool flag3 = statusEffect != null && buildUp > 0;
if (flag3)
{
TinyEffectManager.AddStatusEffectBuildUp(imbueEffectPreset, (float)buildUp, statusEffect);
}
bool flag4 = scalingDamage > 0f || flatDamage > 0f;
if (flag4)
{
TinyEffectManager.AddWeaponDamage(imbueEffectPreset, flatDamage, scalingDamage, damageType);
}
bool flag5 = skill != null;
if (flag5)
{
skill.GetComponentInChildren <ImbueWeapon>().ImbuedEffect = imbueEffectPreset;
}
result = imbueEffectPreset;
}
else
{
result = null;
}
return(result);
}
// Token: 0x0600001F RID: 31 RVA: 0x00002A30 File Offset: 0x00000C30
public static WeaponDamage AddWeaponDamage(ImbueEffectPreset effect, float baseDamage, float damageScaling, DamageType.Types damageType)
{
WeaponDamage weaponDamage = effect.transform.Find("Effects").gameObject.AddComponent <WeaponDamage>();
weaponDamage.WeaponDamageMult = 1f + damageScaling;
weaponDamage.OverrideDType = damageType;
weaponDamage.Damages = new DamageType[]
{
new DamageType(damageType, baseDamage)
};
weaponDamage.OverrideEffectCategory = EffectSynchronizer.EffectCategories.Hit;
return(weaponDamage);
}
public EleEssencePrefix(DamageType.Types type, string name)
{
this.type = type;
this.name = name;
}
