public static bool Prefix(Weapon __instance, RaycastHit _hit, Vector3 _dir)
{
Hitbox hitbox = _hit.collider.GetComponent <Hitbox>();
var owner = __instance.OwnerCharacter;
var target = hitbox.OwnerChar;
var m_alreadyHitChars = At.GetValue(typeof(Weapon), __instance, "m_alreadyHitChars") as List <Character>;
if (!m_alreadyHitChars.Contains(target) && HookUtil.IsElligable(__instance, owner, target))
{
bool blocked = false;
float num = Vector3.Angle(hitbox.OwnerChar.transform.forward, owner.transform.position - hitbox.OwnerChar.transform.position);
if (!__instance.Unblockable && hitbox.OwnerChar.Blocking && num < (float)(hitbox.OwnerChar.ShieldEquipped ? Weapon.SHIELD_BLOCK_ANGLE : Weapon.BLOCK_ANGLE))
{
blocked = true;
}
if (!blocked)
{
var getID = At.GetValue(typeof(Weapon), __instance, "m_attackID");
if (getID is int attackID && attackID >= 0)
{
DamageList damages = __instance.GetDamage(attackID).Clone();
target.Stats.GetMitigatedDamage(null, ref damages);
DamageLabels.AddDamageLabel(damages, _hit.point, target);
}
}
}
return(true);
}
public static void Postfix(Character __instance, ref DamageList __result, Weapon _weapon, DamageList _damage, Vector3 _hitDir, Vector3 _hitPoint, float _angle, float _angleDir, Character _dealerChar, float _knockBack, bool _hitInventory)
{
bool flag = SkillRequirements.CanEnrageFromDamage(__instance) && __result.TotalDamage > 0f;
if (flag)
{
__instance.StatusEffectMngr.AddStatusEffectBuildUp(ResourcesPrefabManager.Instance.GetStatusEffectPrefab("Rage"), _damage.TotalDamage, __instance);
}
bool flag2 = SkillRequirements.CanTerrify((_weapon != null) ? _weapon.OwnerCharacter : null) && __result.TotalDamage > 0f;
if (flag2)
{
List <Character> list = new List <Character>();
CharacterManager.Instance.FindCharactersInRange(__instance.CenterPosition, 7f, ref list);
list = (from c in list
where c.Faction == __instance.Faction
select c).ToList <Character>();
foreach (Character character in list)
{
StatusEffectManager statusEffectMngr = character.StatusEffectMngr;
bool flag3 = statusEffectMngr != null;
if (flag3)
{
bool flag4 = statusEffectMngr.HasStatusEffect("Confusion");
statusEffectMngr.AddStatusEffectBuildUp(ResourcesPrefabManager.Instance.GetStatusEffectPrefab("Confusion"), Mathf.Clamp(__result.TotalDamage, 0f, 20f), character);
bool flag5 = !flag4 && statusEffectMngr.HasStatusEffect("Confusion");
if (flag5)
{
CasualStagger.Stagger(character);
}
}
}
}
}
// Token: 0x06000041 RID: 65 RVA: 0x000048C0 File Offset: 0x00002AC0
protected override void ActivateLocally(Character character, object[] _infos)
{
float num = 15f;
object value = At.GetValue(typeof(Effect), this, "m_parentStatusEffect");
StatusEffect parent = value as StatusEffect;
bool flag = parent != null;
if (flag)
{
float num2 = num - parent.RemainingLifespan;
float damage = Radiating.AmpDamage(parent.SourceCharacter, 15f * Convert.ToSingle(Math.Exp((double)(-(double)num2 / 10f))) / Radiating.normalize(), DamageType.Types.Electric);
List <Character> list = new List <Character>();
CharacterManager.Instance.FindCharactersInRange(character.CenterPosition, 10f, ref list);
IEnumerable <Character> source = list;
foreach (Character character2 in source.Where(x => x.Faction != parent.SourceCharacter.Faction))
{
bool flag2 = !character2.Invincible;
if (flag2)
{
DamageList damageList = new DamageList(DamageType.Types.Electric, damage);
character2.Stats.GetMitigatedDamage(null, ref damageList);
character2.Stats.ReceiveDamage(damageList.TotalDamage);
}
}
}
else
{
Debug.Log("Radiating Effect had not parent Status Effect");
}
}
public static bool Prefix(Weapon __instance, Character _hitCharacter, Vector3 _hitPos, Vector3 _dir, bool _blocked)
{
Character selfChar = At.GetValue(typeof(Item), __instance as Item, "m_ownerCharacter") as Character;
if (At.GetValue(typeof(Weapon), __instance as Weapon, "m_alreadyHitChars") is List <Character> alreadyhit)
{
bool eligible = _hitCharacter && (_hitCharacter != selfChar) && (__instance.CanHitEveryoneButOwner || selfChar.TargetingSystem.IsTargetable(_hitCharacter));
if (eligible && !alreadyhit.Contains((Character)_hitCharacter))
{
if (!_blocked)
{
DamageList damages = __instance.GetDamage(0);
_hitCharacter.Stats.GetMitigatedDamage(null, ref damages);
DamageLabels.AddDamageLabel(damages, _hitPos, _hitCharacter);
}
else
{
// Attack was blocked.
}
}
}
return(true);
}
public void OnSFXDestroy(MeteorUnit unit, Collider co)
{
if (DamageList.ContainsKey(unit))
{
DamageList[unit].Remove(co);
}
}
private void PickBestEquipment(CharacterBuild build, SlotID equipType, Action <CharacterBuild, EquipmentModel> setEquipment)
{
DamageList highest = null;
EquipmentModel highestEquipment = default;
var usedTypes = build.GetDamageTypes();
var relevantGear = new List <EquipmentModel>();
foreach (var type in usedTypes)
{
relevantGear.AddRange(Database.GetDamageBonusEquipment(equipType, type));
}
foreach (var option in relevantGear)
{
var clone = build.Clone();
setEquipment.Invoke(clone, option);
var newDmg = clone.GetWeaponDamage(Enemy, NaturalHexes, ConsiderWeaponHex);
if (highest == null || newDmg.TotalDamage > highest.TotalDamage)
{
highestEquipment = option;
highest = newDmg;
}
}
setEquipment.Invoke(build, highestEquipment);
}
// 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);
}
public static bool Prefix(Weapon __instance, Character _hitCharacter, Vector3 _hitPos, Vector3 _dir, bool _blocked)
{
var selfChar = At.GetField(__instance, "m_ownerCharacter") as Character;
var alreadyhit = At.GetField(__instance, "m_alreadyHitChars") as List <Character>;
bool eligible = _hitCharacter && (_hitCharacter != selfChar) && (__instance.CanHitEveryoneButOwner || selfChar.TargetingSystem.IsTargetable(_hitCharacter));
if (eligible && !alreadyhit.Contains(_hitCharacter))
{
if (!_blocked)
{
DamageList damages = __instance.GetDamage(0);
//_hitCharacter.Stats.GetMitigatedDamage(null, ref damages, false);
At.Invoke(_hitCharacter, "ProcessDamageReduction", new object[] { __instance, damages, false });
DamageLabels.AddDamageLabel(damages, _hitPos, _hitCharacter);
}
else
{
// Attack was blocked.
}
}
return(true);
}
public DamageListForServer ApplyDamage(int serverId, ulong sceneGuid, DamageList damage)
{
WorldBoss boss;
if (WorldBossManager.Boss.TryGetValue(serverId, out boss))
{
return(boss.ApplyDamage(sceneGuid, damage));
}
return(null);
}
public static void Prefix(CharacterStats __instance, ref DamageList _damages, ref Character ___m_character)
{
Character character = ___m_character;
Weapon weapon = (character != null) ? character.CurrentWeapon : null;
bool flag = weapon == null;
if (!flag)
{
CustomBehaviourFormulas.PreAmplifyDamage(weapon, ref _damages);
}
}
// --------- from game class to our holder ----------
public static List <SL_Damage> ParseDamageList(DamageList list)
{
var damages = new List <SL_Damage>();
foreach (DamageType type in list.List)
{
damages.Add(ParseDamageType(type));
}
return(damages);
}
public static DamageList GetDamageList(List <SL_Damage> list)
{
var newlist = new DamageList();
foreach (var entry in list)
{
newlist.Add(entry.GetDamageType());
}
return(newlist);
}
public static List <float> DamageListToFloatArray(DamageList list, float multiplier)
{
var floats = new List <float>();
foreach (var type in list.List)
{
floats.Add(type.Damage * multiplier);
}
return(floats);
}
public static bool Prefix(ref DamageList _damage, Character __instance)
{
if (__instance.IsAI)
{
return(true);
}
MitigationOverride.Calculate(_damage, __instance, true);
return(false);
}
public static bool Prefix(Character ___m_character, ref DamageList _damages)
{
if (___m_character.IsAI)
{
return(true);
}
MitigationOverride.Calculate(_damages, ___m_character, false);
return(false);
}
void OnServerInitialized()
{
try
{
LoadConfig();
config = JsonConvert.DeserializeObject <DamageList>(JsonConvert.SerializeObject(Config["damage_list"]).ToString());
}
catch (Exception ex)
{
Puts("OnServerInitialized failed: " + ex.Message);
}
}
public static void Postfix(PunctualDamage __instance, Character _targetCharacter)
{
if (_targetCharacter.Alive)
{
var damageList = At.GetField(__instance, "m_tempList") as DamageList;
DamageList damages = damageList.Clone();
_targetCharacter.Stats.GetMitigatedDamage(null, ref damages, false);
DamageLabels.AddDamageLabel(damages, _targetCharacter.CenterPosition, _targetCharacter);
}
}
public static void Postfix(
Character __instance,
Vector3 _hitDir,
DamageList _damage,
Character _dealerChar)
{
var character = __instance;
var blockDamageModifier = 0f;
if (character.ShieldEquipped)
{
blockDamageModifier = modSettings.shield;
}
else
{
switch (character.CurrentWeapon.Type)
{
case (Weapon.WeaponType.Sword_1H):
blockDamageModifier = modSettings.sword1h;
break;
case (Weapon.WeaponType.Sword_2H):
blockDamageModifier = modSettings.sword2h;
break;
case (Weapon.WeaponType.Axe_1H):
blockDamageModifier = modSettings.axe1h;
break;
case (Weapon.WeaponType.Axe_2H):
blockDamageModifier = modSettings.axe2h;
break;
case (Weapon.WeaponType.Mace_1H):
blockDamageModifier = modSettings.mace1h;
break;
case (Weapon.WeaponType.Mace_2H):
blockDamageModifier = modSettings.mace2h;
break;
case (Weapon.WeaponType.Spear_2H):
blockDamageModifier = modSettings.spear;
break;
case (Weapon.WeaponType.Halberd_2H):
blockDamageModifier = modSettings.halberd;
break;
}
}
character.VitalityHit(_dealerChar, _damage.TotalDamage * blockDamageModifier, _hitDir);
}
private IEnumerator GetDamageCoroutine(Character self)
{
float start = Time.time;
while (Time.time - start < 5f && LastAttackID == (int)typeof(Weapon).GetField("m_attackID", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(self.CurrentWeapon))
{
yield return(new WaitForSeconds(0.05f));
}
LastAttackID = (int)typeof(Weapon).GetField("m_attackID", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(self.CurrentWeapon);
LastDamage = LastAttackID == 0 ? self.CurrentWeapon.GetDamage(1) : self.CurrentWeapon.GetDamage(LastAttackID);
}
public static void Postfix(PunctualDamage __instance, Character _targetCharacter)
{
if (_targetCharacter.Alive)
{
if (At.GetValue(typeof(PunctualDamage), __instance, "m_tempList") is DamageList damagelist)
{
DamageList damages = damagelist.Clone();
_targetCharacter.Stats.GetMitigatedDamage(null, ref damages);
DamageLabels.AddDamageLabel(damages, _targetCharacter.CenterPosition, _targetCharacter);
}
}
}
// ======================= methods ===========================
public void MitigateDamage(ref DamageList damages, bool applyToActiveCount = true)
{
float current = m_activeProtection;
foreach (var dmg in damages.List)
{
MitigateDamage(ref dmg.Damage);
}
if (!applyToActiveCount)
{
m_activeProtection = current;
}
}
public static void Postfix(PunctualDamage __instance, Character _targetCharacter)
{
if (_targetCharacter.Alive)
{
DamageList damages = (At.GetField(__instance, "m_tempList") as DamageList).Clone();
Weapon weapon = At.GetField(__instance, "m_weapon") as Weapon;
At.Invoke(_targetCharacter, "ProcessDamageReduction", new object[] { weapon, damages, false });
// _targetCharacter.Stats.GetMitigatedDamage(null, ref damages, false);
DamageLabels.AddDamageLabel(damages, _targetCharacter.CenterPosition, _targetCharacter);
}
}
public static void AddDamageLabel(DamageList damageList, Vector3 hitPosition, Character target)
{
if (damageList.TotalDamage < (float)CombatHUD.config.GetValue(Settings.MinimumDamage))
{
return;
}
if (target.IsAI && !(bool)CombatHUD.config.GetValue(Settings.PlayerDamageLabels))
{
return;
}
if (!target.IsAI && !(bool)CombatHUD.config.GetValue(Settings.EnemyDamageLabels))
{
return;
}
Color damagecolor = Color.white;
if (!(bool)CombatHUD.config.GetValue(Settings.DisableColors))
{
float highest = 0f;
foreach (DamageType type in damageList.List)
{
if (type.Damage > highest)
{
highest = type.Damage;
damagecolor = GetDmgColor(type.Type);
}
}
}
var x = CombatHUD.Rel(30f);
var y = CombatHUD.Rel(15f, true);
DamageLabel label = new DamageLabel
{
CreationTime = Time.time,
TextColor = damagecolor,
Damage = damageList.TotalDamage,
HitWorldPos = hitPosition,
Target = target,
ranXpos = UnityEngine.Random.Range(-x, x),
ranYpos = UnityEngine.Random.Range(-y, y)
};
ActiveLabels.Add(label);
}
public void ClearAll()
{
LoadLevelList.Clear();
StartTestDriveList.Clear();
FinishTestDriveList.Clear();
StartGameList.Clear();
FinishGameList.Clear();
RoundGameList.Clear();
StartActiveBattleList.Clear();
PlayerLoadList.Clear();
DamageList.Clear();
KillList.Clear();
KillAssistList.Clear();
ScoreList.Clear();
DecalList.Clear();
}
// Token: 0x06000026 RID: 38 RVA: 0x00003C9C File Offset: 0x00001E9C
public static void StaticActivate(Character character, object[] _infos, Effect instance)
{
float localRangeSquared = 100f;
Dictionary <Character, float> dictionary = new Dictionary <Character, float>();
List <Character> list = new List <Character>();
CharacterManager.Instance.FindCharactersInRange(character.CenterPosition, CelestialSurge.range + 10f, ref list);
list = (from c in list
where c.Faction != character.Faction
select c).ToList <Character>();
using (IEnumerator <Character> enumerator = (from c in list
where c.StatusEffectMngr.HasStatusEffect("Radiating")
select c).GetEnumerator())
{
while (enumerator.MoveNext())
{
Character chr = enumerator.Current;
float num = CelestialSurge.AmpDamage(character, Radiating.sumTicks(chr.StatusEffectMngr.GetStatusEffectOfName("Radiating").RemainingLifespan) + 40f, DamageType.Types.Electric);
IEnumerable <Character> source = list;
foreach (Character character2 in source.Where(c => (c.transform.position - chr.transform.position).sqrMagnitude <= localRangeSquared))
{
bool flag = !character2.Invincible;
if (flag)
{
float num2;
dictionary[character2] = (dictionary.TryGetValue(character2, out num2) ? num2 : 0f) + num;
}
}
}
}
foreach (KeyValuePair <Character, float> keyValuePair in dictionary)
{
DamageList damageList = new DamageList(DamageType.Types.Electric, keyValuePair.Value);
keyValuePair.Key.Stats.GetMitigatedDamage(null, ref damageList);
keyValuePair.Key.Stats.ReceiveDamage(damageList.TotalDamage);
bool flag2 = damageList.TotalDamage > 55f;
if (flag2)
{
keyValuePair.Key.AutoKnock(true, Vector3.zero);
}
else
{
CasualStagger.Stagger(keyValuePair.Key);
}
}
}
private DamageList receiveHit(On.Character.orig_ReceiveHit orig, Character self, Weapon _weapon, DamageList _damage, Vector3 _hitDir, Vector3 _hitPoint, float _angle, float _angleDir, Character _dealerChar, float _knockBack, bool _hitInventory)
{
DamageList changedDamages = null;
if (!self.TargetingSystem.Locked)
{
if (self.IsAI || (!self.IsAI && effectPlayer))
{
changedDamages = _damage.Clone();
for (int i = 0; i < changedDamages.Count; ++i)
{
changedDamages[i].Damage *= sneakMult;
}
}
}
return(orig(self, _weapon, changedDamages ?? _damage, _hitDir, _hitPoint, _angle, _angleDir, _dealerChar, _knockBack, _hitInventory));
}
// 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 static bool Prefix(Weapon __instance, RaycastHit _hit, Vector3 _dir)
{
Hitbox hitbox = _hit.collider?.GetComponent <Hitbox>();
if (!hitbox)
{
return(true);
}
var owner = __instance.OwnerCharacter;
var target = hitbox.OwnerChar;
if (!target || !owner)
{
return(true);
}
var m_alreadyHitChars = (List <Character>)At.GetField(__instance, "m_alreadyHitChars");
if (!m_alreadyHitChars.Contains(target) && HookUtil.IsElligable(__instance, owner, target))
{
bool blocked = false;
float num = Vector3.Angle(hitbox.OwnerChar.transform.forward, owner.transform.position - hitbox.OwnerChar.transform.position);
if (!__instance.Unblockable && hitbox.OwnerChar.Blocking && num < (float)(hitbox.OwnerChar.ShieldEquipped ? Weapon.SHIELD_BLOCK_ANGLE : Weapon.BLOCK_ANGLE))
{
blocked = true;
}
if (!blocked)
{
var attackID = (int)At.GetField(__instance, "m_attackID");
if (attackID >= 0)
{
DamageList damages = __instance.GetDamage(attackID).Clone();
//target.Stats.GetMitigatedDamage(null, ref damages, false);
At.Invoke(target, "ProcessDamageReduction", new object[] { __instance, damages, false });
DamageLabels.AddDamageLabel(damages, _hit.point, target);
}
}
}
return(true);
}
public static void Prefix(Character __instance, Character _dealerChar, ref DamageList _damage)
{
if (!__instance.ShieldEquipped || !__instance.Blocking)
{
return;
}
for (var i = 0; i < _damage.Count; i++)
{
if (_damage[i].Type == DamageType.Types.Fire ||
_damage[i].Type == DamageType.Types.Frost ||
_damage[i].Type == DamageType.Types.Decay ||
_damage[i].Type == DamageType.Types.Electric ||
_damage[i].Type == DamageType.Types.Ethereal)
{
_damage[i].Damage = 0f;
}
}
}
public static void Postfix(PunctualDamage __instance, Character _targetCharacter)
{
if (_targetCharacter.Alive)
{
var damageList = At.GetField(__instance, "m_tempList") as DamageList;
bool ignoreBarrier = false;
if (__instance.ParentSynchronizer is StatusEffect status)
{
ignoreBarrier = status.IgnoreBarrier;
}
DamageList damages = damageList.Clone();
_targetCharacter.Stats.GetMitigatedDamage(null, ref damages, ignoreBarrier);
DamageLabels.AddDamageLabel(damages, _targetCharacter.CenterPosition, _targetCharacter);
}
}
