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);