public List <Attack> DealDamageToAttacker(Monster p_attacker)
{
List <Attack> list = new List <Attack>();
for (Int32 i = 0; i < 10; i++)
{
Equipment equipment = m_character.Equipment.GetItemAt((EEquipSlots)i) as Equipment;
if (equipment != null)
{
if (i != 1 || !(equipment is MeleeWeapon) || (equipment as MeleeWeapon).GetSubType() != EEquipmentType.TWOHANDED)
{
List <SuffixStaticData> suffixes = equipment.Suffixes;
for (Int32 j = 0; j < suffixes.Count; j++)
{
if (suffixes[j].Effect == ESuffixEffect.ATTACKING_MONSTER_DAMAGED)
{
EDamageType edamageType = suffixes[j].MagicSchool;
if (edamageType == EDamageType.NONE)
{
edamageType = EDamageType.PHYSICAL;
}
Damage p_damages = new Damage(edamageType, (Int32)suffixes[j].GetValueForLevel(equipment.SuffixLevel, equipment.ItemSlot == EItemSlot.ITEM_SLOT_2_HAND), 0f, 1f);
Attack item = new Attack(m_character.FightValues.MainHandAttackValue, 0f, p_damages);
EnchantmentEffectEventArgs item2 = new EnchantmentEffectEventArgs(suffixes[j], p_damages.Value);
m_logEntries.Add(item2);
list.Add(item);
}
}
}
}
}
return(list);
}
public void SwapDamageType(EDamageType _DamageType)
{
CurrentDamageDuration = MaxDamageDuration;
m_PlayerDamageType = _DamageType;
CheckParticleSystem();
}
public static string DamageType2Str(EDamageType eDamageType)
{
switch (eDamageType)
{
case EDamageType.Blunt:
return(DamageBluntName);
case EDamageType.Slashing:
return(DamageSlashingName);
case EDamageType.Piercing:
return(DamagePiercingName);
case EDamageType.Heat:
return(DamageHeatName);
case EDamageType.Electric:
return(DamageElectricName);
case EDamageType.Chemical:
return(DamageChemicalName);
case EDamageType.Psychological:
return(DamagePsychologicalName);
case EDamageType.Emp:
return(DamageEmpName);
default:
return(DamageNoneName);
}
}
public HarmEffect(int damage, EDamageType damageType, int statID, EntityTarget useOn)
{
Damage = damage;
DamageType = damageType;
StatID = statID;
UseOn = useOn;
}
protected override AttackResult DoAttackMonster(Character p_attacker, Monster p_target, Single p_magicPower)
{
Int32 num = 1;
if (p_target != null)
{
GridSlot slot = LegacyLogic.Instance.MapLoader.Grid.GetSlot(p_target.Position);
if (slot != null)
{
num = slot.Entities.Count;
}
Single criticalMagicHitChance = p_attacker.FightValues.CriticalMagicHitChance;
Single magicalCriticalDamageMod = p_attacker.FightValues.MagicalCriticalDamageMod;
EDamageType edamageType = ESkillIDToEDamageType(m_staticData.SkillID);
List <Damage> list = new List <Damage>();
for (Int32 i = 0; i < m_staticData.Damage.Length; i++)
{
DamageData p_data = DamageData.Scale(m_staticData.Damage[i], p_magicPower);
Damage item = Damage.Create(p_data, magicalCriticalDamageMod);
if (item.Type == edamageType)
{
item.IgnoreResistance = p_attacker.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID);
}
item.Value *= num;
list.Add(item);
}
Attack p_attack = new Attack(0f, criticalMagicHitChance, list);
return(p_target.CombatHandler.AttackMonster(p_attacker, p_attack, false, true, edamageType, true, p_attacker.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID)));
}
return(null);
}
// Set Info
public void SetInfo(float damage, Transform source, ICharacter owner, EDamageType type = EDamageType.Unknown)
{
this.damage = damage;
this.source = source;
this.owner = owner;
this.type = type;
}
public int RandomNextState()
{
int State = Random.Range(0, 3);
switch (State)
{
case 0:
m_FishingSpotDamageType = EDamageType.LEFT;
Indicator.sprite = LeftImage;
break;
case 1:
m_FishingSpotDamageType = EDamageType.PULL;
Indicator.sprite = PullImage;
break;
case 2:
m_FishingSpotDamageType = EDamageType.RIGHT;
Indicator.sprite = RightImage;
break;
default:
m_FishingSpotDamageType = EDamageType.NONE;
break;
}
CheckParticleSystem();
return(State);
}
public override void ApplyDamage(int Damage, EDamageType Type, GameObject Instigator)
{
//Don't allow damage if we're in a state where we shouldn't
if (Invulnerable || powerupInvulnerability || isDead)
{
return;
}
//We don't want to receive quick consecutive hits
Invulnerable = true;
Invoke("AllowDamage", 1.0f);
//Base call to receive damage
base.ApplyDamage(Damage, Type, Instigator);
/*
* if (Shield > 0)
* {
* Shield = Mathf.Clamp(Shield -= Damage, 0, maxHealth);
*
* if (OnDamaged != null)
* OnDamaged(Damage, Health, Instigator);
*
* return;
* }
*/
}
private void UpdateRanged()
{
Character member = m_party.GetMember(m_party.CurrentCharacter);
BaseItem itemAt = member.Equipment.GetItemAt(EEquipSlots.RANGE_WEAPON);
if (itemAt != null)
{
Int32 num = (Int32)(member.FightValues.RangedAttackValue + 0.5f);
m_rangedAttack.UpdateLabel(num.ToString(), LocaManager.GetText("CHARACTER_ATTACK_RANGED_TT", num));
Int32 num2 = 0;
Int32 num3 = 0;
for (EDamageType edamageType = EDamageType.PHYSICAL; edamageType < EDamageType._MAX_; edamageType++)
{
num2 += member.FightValues.RangeDamage[edamageType].Minimum;
num3 += member.FightValues.RangeDamage[edamageType].Maximum;
}
String text = num2 + "-" + num3;
m_rangeDamage.UpdateLabel(text, LocaManager.GetText("CHARACTER_DAMAGE_WEAPON", text));
String text2 = LocaManager.GetText("CHARACTER_RANGED_CRIT_CHANCE_TT", (Int32)(member.FightValues.CriticalRangeHitChance * 100f + 0.5f));
String text3 = LocaManager.GetText("CHARACTER_ATTACK_CRIT_DAMAGE_TT", (Int32)(member.FightValues.RangeCriticalDamageMod * 100f + 0.5f));
m_rangedCritChance.UpdateLabel(LocaManager.GetText("CHARACTER_ATTACK_CRIT_CHANCE_INFO", (Int32)(member.FightValues.CriticalRangeHitChance * 100f + 0.5f)), text2);
m_rangedCritDamage.UpdateLabel(LocaManager.GetText("CHARACTER_ATTACK_CRIT_DAMAGE_INFO", (Int32)(member.FightValues.RangeCriticalDamageMod * 100f + 0.5f)), text3);
}
else
{
m_rangedAttack.UpdateLabel("0", String.Empty);
m_rangeDamage.UpdateLabel("0", String.Empty);
m_rangedCritChance.UpdateLabel("0", String.Empty);
m_rangedCritDamage.UpdateLabel("0", String.Empty);
}
}
public Weapon(int power, ISet <int> range, EDamageType damageType, EWeaponType weaponType)
{
Power = power;
Range = range;
DamageType = damageType;
WeaponType = weaponType;
}
protected virtual AttackResult DoAttackMonster(Character p_sorcerer, Monster p_target, Single p_magicPower)
{
if (p_target == null)
{
return(null);
}
Single criticalMagicHitChance = p_sorcerer.FightValues.CriticalMagicHitChance;
Single magicalCriticalDamageMod = p_sorcerer.FightValues.MagicalCriticalDamageMod;
EDamageType edamageType = ESkillIDToEDamageType(m_staticData.SkillID);
Attack attack = new Attack(0f, criticalMagicHitChance);
for (Int32 i = 0; i < m_staticData.Damage.Length; i++)
{
if (m_staticData.Damage[i].Type != EDamageType.HEAL)
{
DamageData p_data = DamageData.Scale(m_staticData.Damage[i], p_magicPower);
Damage item = Damage.Create(p_data, magicalCriticalDamageMod);
if (item.Type == edamageType)
{
item.IgnoreResistance = p_sorcerer.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID);
}
attack.Damages.Add(item);
}
}
p_target.AbilityHandler.ExecuteAttack(p_sorcerer, attack, false, EExecutionPhase.ON_CHARACTER_ATTACKS_MONSTER_BEFORE_DAMAGE_REDUCTION);
Boolean p_isMagic = m_staticData.SkillID != ESkillID.SKILL_WARFARE;
return(p_target.CombatHandler.AttackMonster(p_sorcerer, attack, false, true, edamageType, p_isMagic, p_sorcerer.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID)));
}
public override void TakeDamage(int damage, EDamageType damageType)
{
int damageTaken = (int)((weakAgainst == damageType)?
damage * 1.5f : damage);
currentHealth -= damageTaken;
OnHealthChange();
}
public CDamageInfo(int iDamage, EDamageType eType, CBaseEntity pAttacker, Vector3 vDmgPosition)
{
m_iDamage = m_iBaseDamage = iDamage;
m_pAttacker = pAttacker;
m_vDamagePosition = vDmgPosition;
m_eDamageType = eType;
}
public static bool CalcDot(Character attacker, Character defender, ActBuff buff, EDamageType type, float percent, int fixValue, bool ignoreDefense)
{
XDamage dmg = new XDamage();
dmg.AttackerName = attacker.Name;
dmg.DefenderName = defender.Name;
dmg.Skill = buff.Name;
dmg.Type = (int)type;
switch (type)
{
case EDamageType.TYPE_PHYSICS:
dmg.Value = (int)(percent * attacker.CurrAttr.AP + fixValue);
break;
case EDamageType.TYPE_DARK:
dmg.Value = (int)(percent * (attacker.CurrAttr.AP + attacker.CurrAttr.BAP) + fixValue);
break;
case EDamageType.TYPE_ICE:
dmg.Value = (int)(percent * (attacker.CurrAttr.AP + attacker.CurrAttr.IAP) + fixValue);
break;
case EDamageType.TYPE_LIGHT:
dmg.Value = (int)(percent * (attacker.CurrAttr.AP + attacker.CurrAttr.LAP) + fixValue);
break;
case EDamageType.TYPE_FIRE:
dmg.Value = (int)(percent * (attacker.CurrAttr.AP + attacker.CurrAttr.FAP) + fixValue);
break;
}
CalcDamage(attacker, defender, dmg, ignoreDefense);
return(true);
}
protected override void ParseExtra(String p_extra)
{
if (m_parent == null)
{
m_parent = Grid.FindInteractiveObject(m_parentID);
}
String[] array = p_extra.Split(new Char[]
{
','
});
if (array.Length != 1)
{
throw new FormatException(String.Concat(new Object[]
{
"Could not parse interaction params ",
p_extra,
" because it contains ",
array.Length,
" arguments instead of ",
1
}));
}
Int32 p_staticId = Convert.ToInt32(array[0]);
data = StaticDataHandler.GetStaticData <ChallengesStaticData>(EDataType.CHALLENGES, p_staticId);
m_damageType = data.DamageType;
m_damage = data.Damage;
m_singleTarget = data.SingleTarget;
}
// --------------------------------------------------------------------------------------------
public override void OnInspectorGUI()
{
if (EditorApplication.isPlaying)
{
string showHideButtonLabel = _showDebugControls ? "Hide Debug Tools" : "Show Debug Tools";
if (GUILayout.Button(showHideButtonLabel))
{
_showDebugControls = !_showDebugControls;
}
if (_showDebugControls)
{
Destructible destructible = (Destructible)target;
_debugDamageType = (EDamageType)EditorGUILayout.EnumPopup(_debugDamageType);
if (GUILayout.Button("Take Damage"))
{
destructible.TakeDamage(_debugDamageType);
}
}
}
base.OnInspectorGUI();
}
public DamageResult(EDamageType p_type, Int32 p_effectiveValue, Int32 p_resistedValue, Single p_percentage)
{
Type = p_type;
EffectiveValue = p_effectiveValue;
ResistedValue = p_resistedValue;
Percentage = p_percentage;
}
public void Modify(EDamageType p_type, Single p_factor)
{
Resistance resistance = m_resistance[(Int32)p_type];
resistance.Value = (Int32)Math.Round(resistance.Value * p_factor, MidpointRounding.AwayFromZero);
m_resistance[(Int32)p_type] = resistance;
}
public Damage(EDamageType damageType, float amount, float penetration = 1f, float dispersion = 1f)
{
this.DamageType = damageType;
this.Amount = amount;
this.Penetration = Mathf.Clamp(penetration, 0, 1);
this.Dispersion = Mathf.Clamp(dispersion, 0, 1);
}
private void AttackMonsters(Character p_attacker, List <Object> p_otherTargets, SpellEventArgs p_result, Int32 p_splashDamage)
{
if (p_otherTargets != null && p_otherTargets.Count > 0)
{
Single criticalMagicHitChance = p_attacker.FightValues.CriticalMagicHitChance;
Single magicalCriticalDamageMod = p_attacker.FightValues.MagicalCriticalDamageMod;
EDamageType edamageType = ESkillIDToEDamageType(m_staticData.SkillID);
DamageData p_data = new DamageData(edamageType, p_splashDamage, p_splashDamage);
Damage item = Damage.Create(p_data, magicalCriticalDamageMod);
item.IgnoreResistance = p_attacker.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID);
Attack p_attack = new Attack(0f, criticalMagicHitChance, new List <Damage>
{
item
});
foreach (Object obj in p_otherTargets)
{
if (obj != null && obj is Monster && ((Monster)obj).CurrentHealth > 0)
{
AttackResult attackResult = ((Monster)obj).CombatHandler.AttackMonster(p_attacker, p_attack, false, true, edamageType, true, p_attacker.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID));
((Monster)obj).ApplyDamages(attackResult, p_attacker);
p_result.SpellTargets.Add(new AttackedTarget((Monster)obj, attackResult));
}
}
}
}
public EDefenseType Damage(int amount, EDamageType type)
{
var response = Character.Defenses.GetDefense(type);
switch (response)
{
case EDefenseType.Normal:
Character.DamageHealth(amount);
break;
case EDefenseType.Resisted:
break;
case EDefenseType.Weakness:
break;
case EDefenseType.Nullified:
break;
case EDefenseType.Reflected:
break;
default:
break;
}
if (!Character.Alive)
{
Sprite.gameObject.SetActive(false);
}
return(response);
}
public override void SufferAttack(CharacterFeatures ennemy, EDamageType damageType)
{
var currentLifeBeforeAttack = CurrentLife;
base.SufferAttack(ennemy, damageType);
SufferedDamage += currentLifeBeforeAttack - CurrentLife;
}
public override void OnTakeDamage(GameObject attacker, float dmgAmount, EDamageType dmgType = EDamageType.Generic)
{
base.OnTakeDamage(attacker, dmgAmount, dmgType);
HitNoiseSource.Play();
// Alert nearby AI
NoiseMaker.MakeNoise(transform, 100.0f, attacker);
}
public virtual Boolean TestEvade(Single p_attackValue, Single p_evadeValue, EDamageType p_damageType, Int32 p_ignoreResistance)
{
if (p_damageType == EDamageType.PHYSICAL)
{
return(TestEvadePhysical(p_attackValue, p_evadeValue, p_damageType));
}
return(TestEvadeSpell(p_damageType, p_ignoreResistance));
}
public void DamageFish(EDamageType _DamageType, float _Damage)
{
Fish FishScript = spawnedFish.GetComponent <Fish>();
if (m_FishingSpotDamageType == m_PlayerDamageType && spawnedFish)
{
FishScript.TakeDamage(_Damage);
}
}
public Weapon(int power, ISet <int> range, int accuracy, int crit, EDamageType damageType, EWeaponType weaponType)
{
Power = power;
Range = range;
Accuracy = accuracy;
Crit = crit;
DamageType = damageType;
WeaponType = weaponType;
}
public static void DealDamage(GameObject DamagedObject, int DamageAmount, EDamageType DamageType, GameObject Instigator)
{
HealthComp health = DamagedObject.GetComponent <HealthComp>();
if (health)
{
health.ApplyDamage(DamageAmount, DamageType, Instigator);
}
}
public override void TakeDamage(int damage, EDamageType damageType)
{
if (bIsInvulnerable) return;
currentHealth -= damage; //player doesn't care about damage types
if (currentHealth <= 0)
OnPlayerDeath();
}
public static void DealRadialDamage(float Radius, Vector3 Position, int Damage, EDamageType DamageType, GameObject Instigator)
{
Collider[] hits = Physics.OverlapSphere(Position, Radius);
foreach (Collider hit in hits)
{
DealDamage(hit.gameObject, Damage, DamageType, Instigator);
}
}
public Damage(EDamageType p_type, Int32 p_damageValue, Single p_criticalBonusMod, Single p_percentage)
{
Type = p_type;
Value = p_damageValue;
CriticalBonusMod = p_criticalBonusMod;
IgnoreResistance = 0;
IgnoreResistancePercent = 0f;
percentage = p_percentage;
}
public CDamageInfo(int iDamage, int iMinDmg, int iMaxDmg, EDamageType eType, CBaseEntity pAttacker, Vector3 vDmgPosition, Vector3 vForce)
{
m_iDamage = m_iBaseDamage = iDamage;
m_pAttacker = pAttacker;
m_vDamagePosition = vDmgPosition;
m_vForce = vForce;
m_iMinDamage = iMinDmg;
m_iMaxDamage = iMaxDmg;
m_eDamageType = eType;
}
public static void OnDiedEvent(EDamageType damageType)
{
var requestData = new
{
type = "Died",
damageType
};
SendRequest(requestData);
}
internal IntModifier GetPower(EDamageType a_type)
{
IntModifier mod = null;
switch(a_type)
{
case EDamageType.Slashing :
case EDamageType.Crushing :
case EDamageType.Piercing : mod = PhysicalBonusDamages;
break;
default : mod = new IntModifier();
break;
}
return mod;
}
internal Reduction GetPenetration(EDamageType a_type)
{
Reduction result;
switch(a_type)
{
case EDamageType.Slashing :
case EDamageType.Crushing :
case EDamageType.Piercing :
result = PhysicalPenetration;
break;
default : result = new Reduction();
break;
}
return result;
}
internal Reduction GetResistance(EDamageType type, Reduction a_arpen)
{
Resistance reduc;
switch(type)
{
case EDamageType.Slashing :
reduc = general + slashing;
break;
case EDamageType.Crushing :
reduc = general + crushing;
break;
case EDamageType.Piercing :
reduc = general + piercing;
break;
case EDamageType.Magic :
reduc = general + magic;
break;
case EDamageType.True :
reduc = new Resistance();
break;
default:
reduc = new Resistance();
break;
}
Reduction result = new Reduction();
result.percent = ComputePercentReduction(reduc.armor, a_arpen);
result.flat = ComputeFlatReduction(reduc.flat, a_arpen);
return result;
}
public abstract void TakeDamage(int damage, EDamageType damageType);
