public DamageIncreaseData getDamageIcreaseAmounts(float amount, DamageTypes damageType, bool fromCard) { DamageIncreaseData damageIncreaseData = new DamageIncreaseData(amount, damageType, fromCard); damageIncreaseData = updateDamageIncreseData(damageIncreaseData); return(damageIncreaseData); }
/// <summary> /// Gets the total amount of damage a given damage amount will do to a character modified by /// the character's stats. /// </summary> /// <param name="damage">The unmodified amount of damage.</param> /// <param name="character">The character whose stats are being calculated against.</param> /// <returns>An integer representing the total damage that will be dealt to the character.</returns> public static int GetTotalDamage(DamageTypes damageType, Character character) { int totalDamage = 0; int[] damage = damageType.AsArray(); for (int j = 0; j < damage.Count(); j++) { // If a specific type of armor is over 100% (meaning heals instead of damages) then target heals for any percentage of the damage // over 100% if (character.ArmorPercentage.AsArray()[j] > 100 && damage[j] > 0) { totalDamage += damage[j] * (100 - character.ArmorPercentage.AsArray()[j]) / 100; } // If resist all percentage is over 100%, target heals for any percentage of damage over 100% else if (character.ResistAllPercentage > 100 && damage[j] > 0) { totalDamage += damage[j] * (100 - character.ResistAllPercentage) / 100; } // If damage is greater than the target's armor, calculate total damage by deducting target's armor values from damage else if (damage[j] > character.Armor.AsArray()[j]) { totalDamage -= (damage[j] - character.Armor.AsArray()[j]) * (100 - character.ArmorPercentage.AsArray()[j]) / 100 * (100 - character.ResistAllPercentage) / 100; } } return(totalDamage); }
public Weapon() { _maxDamage = 0; _dmgVariance = 0; _maxRange = 0; _dmgType = DamageTypes.Bashing; }
public Stats(Basis _BasisStats, FlatBonus _FlatBoni, PercentageBonus _PercentageBoni, ArmorTypes _ArmorType, DamageTypes _DamageType) { basis = _BasisStats; flatBonus = _FlatBoni; percentageBonus = _PercentageBoni; ArmorType = _ArmorType; DamageType = _DamageType; this.current_Health = max_Health; this.current_Strength = max_Strength; this.current_HealthRegen = max_HealthRegen; this.current_Mana = max_Mana; this.current_Magic = max_Magic; this.current_Intelligence = max_Intelligence; this.current_ManaRegen = max_ManaRegen; this.current_Rage = max_Rage; this.current_Attack = max_Attack; this.current_Energy = max_Energy; this.current_WalkSpeed = max_WalkSpeed; this.current_RunSpeed = max_RunSpeed; this.current_Dexterity = max_Dexterity; this.current_Armor = max_Armor; this.current_MagicResistence = max_MagicResistence; }
public static string DamageTypeToString(DamageTypes type) { switch (type) { case DamageTypes.Piercing: return(StringLiterals.Piercing); case DamageTypes.Slashing: return(StringLiterals.Slashing); case DamageTypes.Bludgeoning: return(StringLiterals.Bludgeoning); case DamageTypes.Nature: return(StringLiterals.Nature); case DamageTypes.Fire: return(StringLiterals.Fire); case DamageTypes.Cold: return(StringLiterals.Cold); case DamageTypes.Arcane: return(StringLiterals.Arcane); case DamageTypes.Electric: return(StringLiterals.Electric); default: return(null); } }
public Weapon(Kits restriction, string name, WeaponSlots slot, DamageTypes damage) { this.KitRestriction = restriction; this.Name = name; this.Slot = slot; this.Damage = damage; }
public virtual void TestPower(Type type, ActionType actionType, AttackType attackType, string range, DamageTypes damageTypes, string effect, EffectTypes effectTypes, PowerFrequency frequency, PowerSource powerSource, string trigger) { Power power; power = Character.GetPowers().Where(x => (x.GetType() == type)).First(); Assert.NotNull(power, "Power not found"); Assert.AreEqual(actionType, power.Action); Assert.AreEqual(attackType, power.AttackTypeAndRange.AttackType); Assert.AreEqual(range, power.AttackTypeAndRange.Range); Assert.AreEqual(damageTypes, power.DamageTypes); Assert.AreEqual(effect != null, power.HasEffect); if (effect != null) { Assert.AreEqual(effect, power.Effect); } Assert.AreEqual(effectTypes, power.EffectTypes); Assert.AreEqual(frequency, power.Frequency); Assert.AreEqual(powerSource, power.PowerSource); Assert.AreEqual(trigger != null, power.HasTrigger); if (trigger != null) { Assert.AreEqual(trigger, power.Trigger); } }
public Spell(String name, String fxName, String animName, float timePerMana, int DamagePerLevel, DamageTypes DamgeType, SPELL_TYPE SpellType, bool CanTurnDuringInvest, bool CanChangeTargetDuringInvest, bool isMultiEffect, SPELL_TARGET_COLLECT TargetCollectAlgo, SPELL_TARGET_TYPES TargetCollectType, int TargetCollectRange, int TargetCollectAzi, int TargetCollectElev, int[] chargeMana) : this() { if (chargeMana == null) { throw new ArgumentException("chargeMana can not be null!"); } spell.processMana = chargeMana; spell.Name = name; spell.FXName = fxName; spell.AniName = animName; spell.TimePerMana = timePerMana; spell.DamagePerLevel = DamagePerLevel; spell.DamageType = DamgeType; spell.SpellType = SpellType; spell.CanTurnDuringInvest = CanTurnDuringInvest; spell.CanChangeTargetDuringInvest = CanChangeTargetDuringInvest; spell.isMultiEffect = isMultiEffect; spell.TargetCollectionAlgo = TargetCollectAlgo; spell.TargetCollectType = TargetCollectType; spell.TargetCollectRange = TargetCollectRange; spell.TargetCollectAzi = TargetCollectAzi; spell.TargetCollectElev = TargetCollectElev; CreateSpell(); }
public HitDamage(int damage, int noDefDamage, int element, DamageTypes type) { Value = damage; NoDefenceValue = noDefDamage; Element = element; Dtype = type; }
public override float GetDamage( WeaponComponentData attackerWeapon, DamageTypes damageType, bool isAlternativeAttack) { return(isAlternativeAttack || attackerWeapon == null || WeaponComponentData.GetItemTypeFromWeaponClass(attackerWeapon.WeaponClass) != ItemObject.ItemTypeEnum.Thrown ? 0.0f : this._value); }
public void TakeDamage(int damageAmount, DamageTypes damageType) { if (!immunitys.Contains(damageType)) { if (damageType == DamageTypes.ONEHIT) { damageAmount = CurrentHp; } if (damageAmount >= 0) { playSound(); } CurrentHp -= damageAmount; HpPercentChange(); if (CurrentHp <= 0) { CurrentHp = 0; Die(); } if (CurrentHp > maxHp) { CurrentHp = maxHp; } } else { Debug.Log("Was imune"); } }
public static DamageTypeIndex getDamageTypeIndex(this DamageTypes s1) { switch (s1) { case DamageTypes.DAM_INVALID: return(DamageTypeIndex.DAM_INDEX_MAX); case DamageTypes.DAM_BARRIER: return(DamageTypeIndex.DAM_INDEX_BARRIER); case DamageTypes.DAM_BLUNT: return(DamageTypeIndex.DAM_INDEX_BLUNT); case DamageTypes.DAM_EDGE: return(DamageTypeIndex.DAM_INDEX_EDGE); case DamageTypes.DAM_FIRE: return(DamageTypeIndex.DAM_INDEX_FIRE); case DamageTypes.DAM_FLY: return(DamageTypeIndex.DAM_INDEX_FLY); case DamageTypes.DAM_MAGIC: return(DamageTypeIndex.DAM_INDEX_MAGIC); case DamageTypes.DAM_POINT: return(DamageTypeIndex.DAM_INDEX_POINT); case DamageTypes.DAM_FALL: return(DamageTypeIndex.DAM_INDEX_FALL); default: return(DamageTypeIndex.DAM_INDEX_BARRIER);; } }
public void DealDamage(List <StatBonus> dmg) { int healthDamage = 0; int comfortDamage = 0; foreach (StatBonus stat in dmg) { DamageTypes type = stat.DamageType; int statDamage = stat.Bonus; if (statDamage > 0) { if (type == DamageTypes.Fire || type == DamageTypes.Physical || type == DamageTypes.Water) { healthDamage += Mathf.Max(0, statDamage - GetResistance(type)); } else if (type == DamageTypes.Noise) { comfortDamage += Mathf.Max(0, statDamage - GetResistance(type)); } else { StenchLevel += Mathf.Max(0, statDamage - GetResistance(type)); } } } healthDamage = Mathf.Min(10, healthDamage); Health -= healthDamage; Comfort -= comfortDamage; //Debug.Log("Took " + healthDamage + " health damage"); //Debug.Log("Took " + comfortDamage + " comfort damage"); }
protected bool IsSatisfied(WeaponComponentData attackerWeapon, DamageTypes damageType) { if (!this.DamageType.HasValue || this.DamageType.Value == damageType) { if (this.WeaponClass.HasValue) { int num = (int)this.WeaponClass.Value; TaleWorlds.Core.WeaponClass?weaponClass = attackerWeapon?.WeaponClass; int valueOrDefault = (int)weaponClass.GetValueOrDefault(); if (!(num == valueOrDefault & weaponClass.HasValue)) { goto label_7; } } switch (this.EffectHitType) { case MPCombatPerkEffect.HitType.Any: return(true); case MPCombatPerkEffect.HitType.Melee: return(!this.IsWeaponRanged(attackerWeapon)); case MPCombatPerkEffect.HitType.Ranged: return(this.IsWeaponRanged(attackerWeapon)); } } label_7: return(false); }
public void SimulateDamage(DamageTypes damageType, int damage) { switch (damageType) { case DamageTypes.LeftWheels: _damageLeftWheels += damage; break; case DamageTypes.RightWheels: _damageRightWheels += damage; break; case DamageTypes.WebCam: _damageWebCam += damage; DoWebCamDamage(); break; case DamageTypes.ControllUnit: _damageControllUnit += damage; CalculateSleepTime(); break; case DamageTypes.Repair: break; default: throw new ArgumentOutOfRangeException(nameof(damageType), damageType, null); } }
public ProjectileStats(string name, float speed, float damage, DamageTypes damageType) { prefabName = name; this.speed = speed; this.damage = damage; this.damageType = damageType; }
/// <summary> /// the most glorious of crappy sorting algorithms /// </summary> /// <returns></returns> public DamageTypes[] Sort() { List <DamageTypes> types = new List <DamageTypes>(); for (int i = 0; i < DamageByTypes.Count; i++) { DamageTypes type = DamageTypes.Standard; float best = -1; for (int j = 0; j < DamageByTypes.Count; j++) { DamageTypes t = (DamageTypes)j; if (DamageByTypes[t] > best && !types.Contains(t)) { best = DamageByTypes[t]; type = t; } } types.Add(type); } return(types.ToArray()); }
public AbilityDamageInfo(DBAbilityDamageInfo dbObj) { Entry = dbObj.Entry; DisplayEntry = dbObj.DisplayEntry; Index = dbObj.Index; ParentCommandID = dbObj.ParentCommandID; ParentCommandSequence = dbObj.ParentCommandSequence; MinDamage = dbObj.MinDamage; MaxDamage = dbObj.MaxDamage; if (!string.IsNullOrEmpty(dbObj.DamageType)) { DamageType = (DamageTypes)Enum.Parse(typeof(DamageTypes), dbObj.DamageType); } DamageVariance = dbObj.DamageVariance; CastTimeDamageMult = dbObj.CastTimeDamageMult; if (!string.IsNullOrEmpty(dbObj.WeaponDamageFrom)) { WeaponMod = (WeaponDamageContribution)Enum.Parse(typeof(WeaponDamageContribution), dbObj.WeaponDamageFrom); } WeaponDamageScale = dbObj.WeaponDamageScale; Undefendable = dbObj.Undefendable; NoCrits = dbObj.NoCrits; OverrideDefenseEvent = dbObj.OverrideDefenseEvent; StatUsed = dbObj.StatUsed; StatDamageScale = dbObj.StatDamageScale; ArmorResistPenFactor = dbObj.ArmorResistPenFactor; HatredScale = dbObj.HatredScale; HealHatredScale = dbObj.HealHatredScale; ResourceBuild = dbObj.ResourceBuild; CastPlayerSubID = dbObj.CastPlayerSubID; PriStatMultiplier = dbObj.PriStatMultiplier; }
public Spell(String name, String fxName, String animName, float timePerMana, int DamagePerLevel, DamageTypes DamgeType, int mana) : this(name, fxName, animName, timePerMana, DamagePerLevel, DamgeType, true, new int[] { mana }) { }
public IEnumerable <KeyValuePair <CraftingTemplate.CraftingStatTypes, float> > GetStatDatas( int usageIndex, DamageTypes thrustDamageType, DamageTypes swingDamageType) { for (int i = 0; i < this._statDataValues[usageIndex].Length; ++i) { CraftingTemplate.CraftingStatTypes key = (CraftingTemplate.CraftingStatTypes)i; bool flag = false; switch (key) { case CraftingTemplate.CraftingStatTypes.ThrustSpeed: case CraftingTemplate.CraftingStatTypes.ThrustDamage: flag = thrustDamageType == DamageTypes.Invalid; break; case CraftingTemplate.CraftingStatTypes.SwingSpeed: case CraftingTemplate.CraftingStatTypes.SwingDamage: flag = swingDamageType == DamageTypes.Invalid; break; } if (!flag && (double)this._statDataValues[usageIndex][i] >= 0.0) { yield return(new KeyValuePair <CraftingTemplate.CraftingStatTypes, float>(key, this._statDataValues[usageIndex][i])); } } }
internal void Damage(DamageTypes damageType) { if (damageType == DamageTypes.Laser) { _laserEffects.Play(); } }
private float GetMountDamage( Agent agent, WeaponComponentData attackerWeapon, DamageTypes damageType, bool isAlternativeAttack) { agent = agent ?? this._peer?.ControlledAgent; float num = 0.0f; foreach (MPPerkEffectBase effect in this._effects) { num += effect.GetMountDamage(attackerWeapon, damageType, isAlternativeAttack); } foreach (MPConditionalEffect conditionalEffect in (List <MPConditionalEffect>) this._conditionalEffects) { if (conditionalEffect.Check(agent)) { foreach (MPPerkEffectBase effect in (IEnumerable <MPPerkEffectBase>)conditionalEffect.Effects) { num += effect.GetMountDamage(attackerWeapon, damageType, isAlternativeAttack); } } } return(num); }
public Damage(AttackTypes attackType, DamageTypes damageType, ushort minDamage, ushort maxDamage) { this.AttackType = attackType; this.DamageType = damageType; this.MinDamage = Math.Min(minDamage, maxDamage); this.MaxDamage = Math.Max(minDamage, maxDamage); }
public void Damage(int value, DamageTypes damageType) { if (!(Time.unscaledTime > _damageTimestamp + _damageCooldown)) { return; } health = Mathf.Max(0, health - value); _damageTimestamp = Time.unscaledTime; _playerEffects.Damage(damageType); if (damageType != DamageTypes.Dash) { PlayerEvents.Instance.TakeDamage(); } if (damageType == DamageTypes.Dash) { PlayerEvents.Instance.TakeDashDamage(); } if (damageType == DamageTypes.Laser) { _damageSound.Play(); } if (health <= 0 && !_isImmortal) { Die(); } }
public static string DamageTypes_GetDamageType(DamageTypes val) { string result = ""; switch (val) { case DamageTypes.Slashing: result = "Slashing"; break; case DamageTypes.Piercing: result = "Piercing"; break; case DamageTypes.Bludgeoning: result = "Bludgeoning"; break; case DamageTypes.Force: result = "Force"; break; case DamageTypes.Poison: result = "Poison"; break; case DamageTypes.Acid: result = "Acid"; break; case DamageTypes.Psychic: result = "Psychic"; break; case DamageTypes.Heat: result = "Heat"; break; case DamageTypes.Cryonic: result = "Cryonic"; break; case DamageTypes.Electric: result = "Electric"; break; case DamageTypes.Concussion: result = "Concussion"; break; case DamageTypes.Radiation: result = "Radiation"; break; case DamageTypes.Rot: result = "Rot"; break; } return(result); }
public void TakeDamage(float damage, DamageTypes type) { if (CanDamage(type)) { CalculateDamage(damage); } }
public virtual float GetMountDamage( WeaponComponentData attackerWeapon, DamageTypes damageType, bool isAlternativeAttack) { return(0.0f); }
public override float GetMountDamage( WeaponComponentData attackerWeapon, DamageTypes damageType, bool isAlternativeAttack) { return(!this.IsSatisfied(attackerWeapon, damageType) ? 0.0f : this._value); }
public Weapon(int mDmg, float dmgVar, float range, DamageTypes dt) { _maxDamage = mDmg; _dmgVariance = dmgVar; _maxRange = range; _dmgType = dt; }
/// <summary> /// Constructs a list of key value pairs containing any element values that are not 0 along /// with the proper UI displayable name. /// </summary> /// <param name="damageTypes">The object containing the element values.</param> /// <param name="appendString">Whether this is Armor, Damage or Resistance.</param> /// <returns></returns> private List <KeyValuePair <string, int> > GetElementalData(DamageTypes damageTypes, string appendString) { var data = new List <KeyValuePair <string, int> >(); if (damageTypes.Physical != 0) { data.Add(new KeyValuePair <string, int>($"Physical {appendString}", damageTypes.Physical)); } if (damageTypes.Fire != 0) { data.Add(new KeyValuePair <string, int>($"Fire {appendString}", damageTypes.Fire)); } if (damageTypes.Frost != 0) { data.Add(new KeyValuePair <string, int>($"Frost {appendString}", damageTypes.Frost)); } if (damageTypes.Lightning != 0) { data.Add(new KeyValuePair <string, int>($"Lightning {appendString}", damageTypes.Lightning)); } if (damageTypes.Shadow != 0) { data.Add(new KeyValuePair <string, int>($"Shadow {appendString}", damageTypes.Shadow)); } if (damageTypes.Light != 0) { data.Add(new KeyValuePair <string, int>($"Light {appendString}", damageTypes.Light)); } return(data); }
/// <summary> /// Calculates the total damage this entity will deal to another entity /// </summary> /// <returns>The amount of total damage this entity will deal</returns> public int CalculateDamageDealt(DamageTypes damageType, Elements element) { int totalDamage = 0; //Calculate physical attack if (damageType == DamageTypes.Physical) { totalDamage = CalculateTotalStat(StatModifiers.StatModTypes.Attack); } //Calculate magic attack else if (damageType == DamageTypes.Magic) { totalDamage = CalculateTotalStat(StatModifiers.StatModTypes.MagicAtk); } //Use the higher of the total physical or magical attack if damageType is None else { int physical = CalculateTotalStat(StatModifiers.StatModTypes.Attack); int magic = CalculateTotalStat(StatModifiers.StatModTypes.MagicAtk); totalDamage = physical >= magic ? physical : magic; } return(Helper.Clamp(totalDamage, Globals.MIN_DMG, Globals.MAX_DMG)); }
/// <summary> /// Calculates total damage received based on this entity's defense, magic defense, and/or weaknesses and resistances, with the /// latter being applied after defense reduction /// </summary> /// <param name="damage">The damage value from the damage source</param> /// <param name ="damageType">The type of damage dealt</param> /// <param name="element">The elemental damage being dealt</param> /// <returns>The amount of total damage dealt to this entity</returns> public int CalculateDamageReceived(int damage, DamageTypes damageType, Elements element) { int totaldamage = damage; if (damageType == DamageTypes.Physical) { totaldamage -= CalculateTotalStat(StatModifiers.StatModTypes.Defense); } else if (damageType == DamageTypes.Magic) { totaldamage -= CalculateTotalStat(StatModifiers.StatModTypes.MagicDef); } if (element != Elements.Neutral) { //Apply weakness modifier if the entity is weak to this element if (Weaknesses.ContainsKey(element)) { totaldamage = (int)((float)totaldamage * Globals.WEAKNESS_MOD); } //Apply resistance modifier if the entity resists this element //The damage will cancel out if the entity both resists and is weak to this element (possible with equipment, spells, etc.) if (Resistances.ContainsKey(element)) { totaldamage = (int)((float)totaldamage * Globals.RESISTANCE_MOD); } } return(Helper.Clamp(totaldamage, Globals.MIN_DMG, Globals.MAX_DMG)); }
/// <inheritdoc/> protected override void OnHurting(HurtingEventArgs ev) { if (ev.Attacker != ev.Target && ev.DamageType == DamageTypes.FromWeaponId(ev.Attacker.ReferenceHub.weaponManager.curWeapon)) { ev.Amount *= DamageMultiplier; } }
public virtual bool TakeDamage(float damage, DamageTypes damageTypes) { if ((damageTypes & IgnoredDamageTypes) == damageTypes) return false; var newHealth = Math.Max(CurrentHealth - damage, 0.0f); if (Math.Abs(newHealth - CurrentHealth) > Eps) HealthChanging(newHealth, false); return true; }
public static int AddEvent(GameObject attacker, GameObject attackable, int damage, DamageTypes damageType, int index){ ActionEvent actionEvent = new ActionEvent (); actionEvent.attackable = attackable; actionEvent.damage = damage; actionEvent.damageType = damageType; actionEvent.attacker = attacker; instance.actionEvents.Insert(index, actionEvent); return(instance.actionEvents.Count - 1); }
public bool SetDamage(DamageTypes type, int damage) { if (Dtype == type || (type == DamageTypes.Physical && Dtype != DamageTypes.Magic) || type == DamageTypes.All) { Value = damage; return true; } return false; }
private Abilities ability; //used for unit abilities, mostly attacking, some defense/support #endregion Fields #region Methods public void ApplyDamage(float damage, DamageTypes damageType, float accuracy) { if(damage > 0){ //called by a projectile when hitting a target float damageModifier = AbsorbDamage(damageType); Debug.Log(gameObject.name+" took ("+ damage +" * "+damageModifier+" - "+defenseRating+") = "+((damage*damageModifier)*defenseRating)+" Damage."); curHealth -= (int)((damage * damageModifier) - defenseRating); Debug.Log("("+damage+" "+damageModifier+" "+defenseRating+")"+" : "+curHealth); } }
public void ReceiveHit(GameObject attacker, int damage, DamageTypes damageType){ if (gameObject != null) { int index = EventQueue.AddMessage (beingName + " surstains " + damage + " damage"); hitPoints -= damage; if (hitPoints < 1) { EventQueue.AddDestroy (gameObject, index + 1); } } }
void Impact(GameObject iTarget, float iDamage, DamageTypes iDamageType, float iAccuracy) { Body body = iTarget.GetComponent<Body>(); body.ApplyDamage(iDamage, iDamageType, iAccuracy); if(persistentEffect != null){ Transform dot = transform.GetChild(0); //var dot = (GameObject) Instantiate (persistentEffect, transform.position, transform.rotation); dot.parent = this.transform; dot.gameObject.SetActive(true); } Trash(); }
public Weapon(string name, string id, int singleRange, int flatDamage, Dice baseDamage, Dice additionalDamage, int shotsPerBurst, AttackRange classification, DamageTypes damageType, WeaponSkillType weaponType, bool pen) { this.Name = name; this.ID = id; this.Range = singleRange; this.FlatDamage = flatDamage; this.BaseDamage = baseDamage; this.AdditionalDamage = additionalDamage; this.ShotsPerBurst = shotsPerBurst; this.Classification = classification; this.DamageType = damageType; this.WeaponType = weaponType; this.Penetrating = pen; }
public virtual void Fire(DamageTypes damageType, bool crit) { firing = true; this.damageType = damageType; transform.SetParent(null, true); critting = crit; if (crit) { myTrail = (GameObject)Instantiate(TrailParticles, transform.position, Quaternion.identity); myTrail.transform.SetParent(transform); myTrail.transform.localRotation = Quaternion.Euler(0, 270, 0); myTrailParticles = myTrail.GetComponent<ParticleSystem>(); myTrailParticles.Play(); } }
public CreatureData(string name, ushort hitPoints, uint experiencePoints, ushort summonMana, ushort convinceMana, bool canSeeInvisible, ushort speed, AbilityTypes abilities, DamageTypes immunities, IEnumerable<Damage> damages, IEnumerable<CreatureData> minions, Dictionary<Loot, Loot.Chance> loot) { this.Name = name; this.HitPoints = hitPoints; this.ExperiencePoints = experiencePoints; this.SummonMana = summonMana; this.ConvinceMana = convinceMana; this.CanSeeInvisible = canSeeInvisible; this.Speed = speed; this.Abilities = abilities; this.Immunities = immunities; this.Damages = damages.ToList(); this.Minions = minions.ToList(); this.Loots = loot; }
float AbsorbDamage(DamageTypes damageType) { switch(defense) { case Defenses.armored: switch(damageType){ case DamageTypes.chemical: break; case DamageTypes.normal: break; case DamageTypes.plasma: break; case DamageTypes.sound: break; } break; case Defenses.ethereal: switch(damageType){ case DamageTypes.chemical: break; case DamageTypes.normal: break; case DamageTypes.plasma: break; case DamageTypes.sound: break; } break; case Defenses.normal: switch(damageType){ case DamageTypes.chemical: break; case DamageTypes.normal: break; case DamageTypes.plasma: break; case DamageTypes.sound: break; } break; } return 1f; }
public static float CalculateDamage(float damageTaken, DamageTypes type, ArmorValues values) { switch (type) { case DamageTypes.Ranged: return (1 / (0.1f * Mathf.Abs(values.BasicArmor) + 1)) * values.RangedDamageMult * damageTaken; case DamageTypes.Melee: return (1 / (0.1f * Mathf.Abs(values.BasicArmor) + 1)) * values.MeleeDamageMult * damageTaken; case DamageTypes.Magic: return (1 / (0.1f * Mathf.Abs(values.ElementalArmor) + 1)) * values.MeleeDamageMult * damageTaken; case DamageTypes.Explosion: return (1 / (0.1f * Mathf.Abs(values.BlastArmor) + 1)) * values.MeleeDamageMult * damageTaken; case DamageTypes.Pierce: return damageTaken; default: Debug.Log("Unknown Damage Type: " + type.ToString()); return damageTaken; } }
public void Damage(float hitPoints) { if (!healthyBarrel || !damagedBarrel || !explosionParticle[0]) gameObject.SetActive(false); switch(damageTypes) { case DamageTypes.Healthy: healthyBarrel.SetActive(false); damagedBarrel.SetActive(true); damageTypes = DamageTypes.Damaged; break; case DamageTypes.Damaged: Kill(); damageTypes = DamageTypes.Destroyed; break; default: //Do absolutely F**K ALL. break; } return; }
public static void SimulateDamage(DamageTypes damageType, int Damage) { switch (damageType) { case DamageTypes.LeftWheels: DamageLeftWheels += Damage; break; case DamageTypes.RightWheels: DamageRightWheels += Damage; break; case DamageTypes.WebCam: DamageWebCam += Damage; DoWebCamDamage(); break; case DamageTypes.ControllUnit: DamageControllUnit += Damage; CalculateSleepTime(); break; case DamageTypes.Repair: break; default: throw new ArgumentOutOfRangeException(nameof(damageType), damageType, null); } }
string item_key(DamageTypes d) { if (d == null) return "No damage key"; try { return Enum.GetName(typeof(DamageTypes), d); } catch { } return "No damage key"; }
string damage_desc(DamageTypes damage) { if (damage == null) return "No damage"; try { return Enum.GetName(typeof(DamageTypes), damage); } catch { } return "No damage"; }
public static XenoWeapon CreateWeapon(DamageTypes type) { if(type==DamageTypes.FLAME) return CreateFlamer(); return CreateGun(); }
public Enchantment(){ bonus = 0; damageType = DamageTypes.none; magicBonusType = MagicBonusType.none; }
public override void TestPower(Type type, ActionType actionType, AttackType attackType, string range, DamageTypes damageTypes, string effect, EffectTypes effectTypes, PowerFrequency frequency, PowerSource powerSource, string trigger) { base.TestPower(type, actionType, attackType, range, damageTypes, effect, effectTypes, frequency, powerSource, trigger); }
void Start() { damageTypes = DamageTypes.Healthy; }
public void ReceiveHit(GameObject attacker, int damage, DamageTypes damageType){ foreach (BuffRiposte buff in buffs) { buff.Perform (this, attacker, damage); } EventQueue.AddMessage (beingName + " sustains " + damage + " damage", 1); hitPoints -= damage; }
public Damage(int value, DamageTypes type, Entity source) { this.value = value; this.type = type; this.source = source; }
public static int AddEvent(GameObject attacker, GameObject attackable, int damage, DamageTypes damageType){ return(AddEvent (attacker, attackable, damage, damageType, instance.actionEvents.Count)); }