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 Weapon(Kits restriction, string name, WeaponSlots slot, DamageTypes damage)
{
this.KitRestriction = restriction;
this.Name = name;
this.Slot = slot;
this.Damage = damage;
}
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 HitDamage(int damage, int noDefDamage, int element, DamageTypes type)
{
Value = damage;
NoDefenceValue = noDefDamage;
Element = element;
Dtype = type;
}
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));
}
