public void ModifyDamage(DamagableObject target, InputDamage inputDamage) { if (nebulaObject.Type == (byte)ItemType.Avatar) { if (HasSkill(m43AID)) { var skill = GetSkillById(m43AID); if (skill.isOn) { var m43a = skill.GetExecutor() as Skill_0000043A; if (target.health < target.maximumHealth * m43a.hpPc) { if (false == Mathf.Approximately(m43a.dmgMult, 0f)) { //log.InfoFormat("modify damage on {0}% with skill 43A", m43a.dmgMult); inputDamage.Mult(m43a.dmgMult); //return inputDamage; } } } } } //return inputDamage; }
public virtual InputDamage ReceiveDamage(InputDamage inputDamage) { nebulaObject.SetInvisibility(false); if (mBonuses) { inputDamage.Mult((1.0f + mBonuses.inputDamagePcBonus)); //inputDamage.SetDamage(inputDamage.damage * (1.0f + mBonuses.inputDamagePcBonus)); ApplyReflection(inputDamage); } if (inputDamage.hasDamager) { var damagerBons = inputDamage.source.Bonuses(); if (damagerBons) { float vampPc = damagerBons.vampirismPcBonus; float hp = inputDamage.totalDamage * vampPc; var dDamagable = inputDamage.source.Damagable(); if (dDamagable) { dDamagable.Heal(new InputHeal(hp)); } } } return(inputDamage); }
public void MoveDamageToSubscriber(InputDamage inputDamage) { float movedDamage = inputDamage.totalDamage; if (nebulaObject.IsPlayer()) { var meRaceable = nebulaObject.Raceable(); foreach (var subscriber in mSubscribers) { if (subscriber.Value) { if (subscriber.Value.IsPlayer()) { if (subscriber.Value.Raceable().race == meRaceable.race) { if (subscriber.Value.Skills().MoveDamageFromAlly(inputDamage.totalDamage, ref movedDamage)) { inputDamage.ClearAllDamages(); inputDamage.SetBaseDamage(movedDamage); } } } } } } }
public override InputDamage ReceiveDamage(InputDamage inputDamage) { float beforeDamage = inputDamage.totalDamage; InputDamage dmg = base.ReceiveDamage(inputDamage); float afterDamage = dmg.totalDamage; if(mOutpost) { //log.InfoFormat("outpost receive damage input = {0} output = {1} [blue]", beforeDamage, afterDamage); } return dmg; }
//public void SetAbsorbDamage(float absorb) { // mAbsorbedDamage = absorb; //} protected virtual void AbsorbDamage(InputDamage inputDamage) { float absorbed = 0; float ret = inputDamage.totalDamage; /* * if(mAbsorbedDamage > 0) { * mAbsorbedDamage -= inputDamage.totalDamage; * if(mAbsorbedDamage >= 0f ) { * absorbed = inputDamage.totalDamage; * ret = 0f; * * } else { * float result = Mathf.Abs(mAbsorbedDamage); * mAbsorbedDamage = NO_ABSORB; * absorbed = Mathf.Abs(inputDamage.totalDamage - result); * ret = result; * * } * }*/ if (mBonuses) { if (ret > 0) { float absorbCnt = mBonuses.absorbDamageCntBonus; if (Mathf.NotEqual(absorbCnt, 0.0f)) { float remainAbsorb = absorbCnt - ret; ret -= absorbCnt; mBonuses.SetAbsrobBuff(remainAbsorb, nebulaObject); } } if (ret > 0) { float absorbPC = mBonuses.absrodDamagePcBonus; float dmgToAbsorbe = ret * absorbPC; ret -= dmgToAbsorbe; float restoreHpPc = mBonuses.convertAbsorbedDamageToHpPcBonus; float hp = (absorbed + dmgToAbsorbe) * restoreHpPc; Heal(new InputHeal(hp)); } } if (ret < 0) { ret = 0; } inputDamage.ClearAllDamages(); inputDamage.SetBaseDamage(ret); //return inputDamage; }
protected override void ModifyDamage(InputDamage damage) { if (damage.ignoreFixedDamage) { //we ignore damage } else { damage.ClearAllDamages(); damage.SetBaseDamage(m_FixedDamage); } }
public void Update(float deltaTime) { if (active) { WeaponDamage dmgPerSec = new WeaponDamage(m_TimedDamageType); dmgPerSec.SetBaseTypeDamage(damagePerSecond * deltaTime); InputDamage inpDamage = new InputDamage(null, dmgPerSec); mTarget.ReceiveDamage(inpDamage); mTimer -= deltaTime; if (mTimer <= 0f) { active = false; } } }
private bool ReflectDamage(DamagableObject targetDamagable, ref WeaponHitInfo hit, InputDamage inputDamage) { bool reflected = targetDamagable.TryReflectDamage(); if (reflected) { if (hit.normal) { DamageParams damageParams = new DamageParams(); damageParams.SetReflrected(true); InputDamage inpDamage = new InputDamage(targetDamagable.nebulaObject, inputDamage.CreateCopy(), damageParams); cachedDamagable.ReceiveDamage(inpDamage); } } return(reflected); }
private void ApplyReflection(InputDamage inputDamage) { if ((false == inputDamage.reflected) && inputDamage.hasDamager) { var reflectValue = mBonuses.reflectionPc; if (false == Mathf.Approximately(reflectValue, 0f)) { float reflectedDamageVal = inputDamage.totalDamage * reflectValue; var attackerDamagable = inputDamage.source.Damagable(); WeaponDamage reflectedDamage = new WeaponDamage(inputDamage.weaponBaseType); reflectedDamage.SetBaseTypeDamage(reflectedDamageVal); if (attackerDamagable) { DamageParams damageParams = new DamageParams(); damageParams.SetReflrected(true); attackerDamagable.ReceiveDamage(new InputDamage(nebulaObject, reflectedDamage, damageParams)); } } } }
private void StartDamageDron(DamagableObject targetObject, WeaponDamage inputDamage, byte workshop, int level, byte race) { if (nebulaObject.IsPlayer()) { if (mPassiveBonuses != null && mPassiveBonuses.damageDronTier > 0) { WeaponDamage dronDamage = new WeaponDamage(); dronDamage.SetFromDamage(inputDamage); dronDamage.Mult(mPassiveBonuses.damageDronBonus); InputDamage inpDamage = new InputDamage(nebulaObject, dronDamage); targetObject.ReceiveDamage(inpDamage); Hashtable dronInfo = new Hashtable { { (int)SPC.Target, targetObject.nebulaObject.Id }, { (int)SPC.TargetType, targetObject.nebulaObject.Type }, { (int)SPC.Damage, dronDamage.totalDamage } }; mMessage.SendDamageDron(dronInfo); } } }
//private float ApplyResistPassiveBonus(float inputResist) { // if(nebulaObject.IsPlayer()) { // if(mPassiveBonuses != null && mPassiveBonuses.resistTier > 0 ) { // return Mathf.Clamp01(inputResist + mPassiveBonuses.resistBonus); // } // } // return inputResist; //} public override InputDamage ReceiveDamage(InputDamage inputDamage) { //firs call base behaviour inputDamage = base.ReceiveDamage(inputDamage); if (!nebulaObject) { inputDamage.ClearAllDamages(); //inputDamage.SetDamage(0.0f); return(inputDamage); } nebulaObject.SendMessage(ComponentMessages.InCombat); if (ignoreDamageAtStart || god) { //if (GetComponent<MmoActor>()) { // log.Info("player damage ignored"); //} //return 0f; inputDamage.ClearAllDamages(); //inputDamage.SetDamage(0.0f); return(inputDamage); } //if(god) { // //log.Info("ShipBasedDamagableObject is GOD, return 0 damage"); // return 0f; //} if (mShip == null) { mShip = GetComponent <BaseShip>(); } float resist = 0f; float acidResist = 0.0f; float laserResist = 0.0f; float rocketResist = 0.0f; if (mShip != null) { resist = mShip.commonResist; acidResist = mShip.acidResist; laserResist = mShip.laserResist; rocketResist = mShip.rocketResist; } //resist = ApplyResistPassiveBonus(resist); inputDamage.Mult(1.0f - Mathf.Clamp01(resist)); inputDamage.Mult(WeaponBaseType.Acid, 1.0f - Mathf.Clamp01(acidResist)); inputDamage.Mult(WeaponBaseType.Laser, 1.0f - Mathf.Clamp01(laserResist)); inputDamage.Mult(WeaponBaseType.Rocket, 1.0f - Mathf.Clamp01(rocketResist)); //inputDamage.SetDamage(inputDamage.damage * (1.0f - Mathf.Clamp01(resist))); AbsorbDamage(inputDamage); //inputDamage.CopyValues(AbsorbDamage(inputDamage.damage)); if (!god) { if (mBonuses) { if (mBonuses.isImmuneToDamage) { inputDamage.ClearAllDamages(); //inputDamage.SetDamage(0f); } } if (nebulaObject.IsPlayer()) { mTarget.MoveDamageToSubscriber(inputDamage); } SubHealth(inputDamage.totalDamage); } if (inputDamage.hasDamager) { AddDamager( inputDamage.sourceId, inputDamage.sourceType, inputDamage.totalDamage, (byte)inputDamage.workshop, inputDamage.level, (byte)inputDamage.race, inputDamage.source); } //if(mEventedObject != null && inputDamage.hasDamager) { // mEventedObject.ReceiveDamage(new DamageInfo(inputDamage.sourceId, inputDamage.sourceType, inputDamage.damage, (byte)inputDamage.workshop, inputDamage.level, (byte)inputDamage.race)); //} if (health <= 0f) { if (NotRespawnBySkill()) { SetWasKilled(true); } else { if (nebulaObject.Type == (byte)ItemType.Avatar) { if (m_Message) { m_Message.ResurrectBySkillEffect(); } } } } return(inputDamage); }
private void ApplyDamage(ref WeaponHitInfo hit, DamagableObject target, float damageMult, bool useDamageMultSelfAsDamage, InputDamage inputDamage) { inputDamage.Mult(damageMult * Rand.NormalNumber(0.8f, 1.2f)); if (useDamageMultSelfAsDamage) { WeaponDamage dmg = new WeaponDamage(inputDamage.weaponBaseType, 0, 0, 0); dmg.SetBaseTypeDamage(damageMult); inputDamage.CopyValues(dmg); } if (cachedSkills) { cachedSkills.ModifyDamage(target, inputDamage); } int level = 1; byte workshop = (byte)Workshop.Arlen; byte race = (byte)Race.None; level = cachedCharacter.level; workshop = cachedCharacter.workshop; RaceableObject raceable = nebulaObject.Raceable(); if (raceable) { race = raceable.race; } var copy = inputDamage.CreateCopy(); if (false == ReflectDamage(target, ref hit, inputDamage)) { target.ReceiveDamage(inputDamage); StartDamageDron(target, inputDamage.CreateCopy(), workshop, level, race); } hit.SetRemainTargetHp(target.health); if (m_Achievments != null) { m_Achievments.OnMakeDamage(copy); } }
protected void CompleteForceShot(NebulaObject obj, ref WeaponHitInfo hit, float damageMult, bool useDamageMultSelfAsDamage, InputDamage inputDamage) { CheckWeaponBlocked(hit); if (hit.normal) { CheckWeaponDistance(obj, hit); if (hit.normal) { UnblockSingleShot(); ApplyDamage(ref hit, obj.Damagable(), damageMult, useDamageMultSelfAsDamage, inputDamage); } } }
public virtual Hashtable Fire(NebulaObject targetObject, out WeaponHitInfo hit, int skillID = -1, float damageMult = 1.0f, bool forceShot = false, bool useDamageMultSelfAsDamage = false) { m_NotResettableShotCounter++; MakeMeVisible(); hit = new WeaponHitInfo(); if (CheckWeaponTarget(targetObject)) { Hashtable result = new Hashtable(); result.Add((int)SPC.Source, nebulaObject.Id); result.Add((int)SPC.SourceType, nebulaObject.Type); result.Add((int)SPC.Target, targetObject.Id); result.Add((int)SPC.TargetType, targetObject.Type); result.Add((int)SPC.Workshop, cachedCharacter.workshop); result.Add((int)SPC.Skill, skillID); //InputDamage inputDamage = new InputDamage(nebulaObject, GetDamage()) if (forceShot) { InputDamage inputDamage = new InputDamage(nebulaObject, GetDamage(false)); CompleteForceShot(targetObject, ref hit, damageMult, useDamageMultSelfAsDamage, inputDamage); inputDamage.SetHitInfo(hit); } else { CheckWeaponBlocked(hit); if (hit.interrupted) { UnblockSingleShot(); WeaponDamage dmg = GetDamage(false); dmg.ClearAllDamages(); InputDamage inputDamage = new InputDamage(nebulaObject, dmg); inputDamage.SetHitInfo(hit); } else { WeaponDamage damage = null; if (IsCritical(ref hit)) { damage = GetDamage(true); } else { damage = GetDamage(false); } InputDamage inputDamage = new InputDamage(nebulaObject, damage); CheckWeaponDistance(targetObject, hit); if (hit.interrupted) { damage.ClearAllDamages(); } else { CheckWeaponHit(targetObject, hit); if (hit.interrupted) { damage.ClearAllDamages(); } else { if (nebulaObject.IsPlayer()) { nebulaObject.SendMessage(ComponentMessages.OnCriticalHit); } shotCounter++; ApplyDamage(ref hit, targetObject.Damagable(), damageMult, useDamageMultSelfAsDamage, inputDamage); } } inputDamage.SetHitInfo(hit); } } foreach (DictionaryEntry entry in hit.GetInfo()) { result[(int)entry.Key] = entry.Value; } CheckPlayerAgro(targetObject); SendFireMessage(hit); //log.InfoFormat("final hit state: {0}", hit.state); return(result); } return(new Hashtable()); }
protected virtual void ModifyDamage(InputDamage damage) { }
public override InputDamage ReceiveDamage(InputDamage inputDamage) { InputDamage damageFromBase = base.ReceiveDamage(inputDamage); if (!nebulaObject) { damageFromBase.ClearAllDamages(); //damageFromBase.SetDamage(0f); return(damageFromBase); } nebulaObject.SendMessage(ComponentMessages.InCombat); if (ignoreDamageAtStart) { if (isFortification) { log.InfoFormat("fortification ignored damage at start [blue]"); } //damageFromBase.SetDamage(0f); damageFromBase.ClearAllDamages(); return(damageFromBase); } if (god) { log.InfoFormat("[{0}]: Bot if GOD, damage ignored [blue]", (nebulaObject.world as MmoWorld).Zone.Id); //damageFromBase.SetDamage(0f); damageFromBase.ClearAllDamages(); return(damageFromBase); } if (mBonuses) { if (mBonuses.isImmuneToDamage) { log.InfoFormat("Has bonus to ignore damage... [blue]"); //damageFromBase.SetDamage(0.0f); damageFromBase.ClearAllDamages(); } } ModifyDamage(damageFromBase); AbsorbDamage(damageFromBase); SubHealth(damageFromBase.totalDamage); if (damageFromBase.hasDamager) { AddDamager( damageFromBase.sourceId, damageFromBase.sourceType, damageFromBase.totalDamage, (byte)damageFromBase.workshop, damageFromBase.level, (byte)damageFromBase.race, damageFromBase.source); } //if (mEventedObject != null) { // mEventedObject.ReceiveDamage(new DamageInfo(damageFromBase.sourceId, damageFromBase.sourceType, damageFromBase.damage, (byte)damageFromBase.workshop, damageFromBase.level, (byte)damageFromBase.race)); //} if (health <= 0f) { SetWasKilled(true); nebulaObject.SendMessage(ComponentMessages.OnWasKilled); } return(damageFromBase); }
protected override void AbsorbDamage(InputDamage inputDamage) { //inputDamage.ClearAllDamages(); //inputDamage.SetBaseDamage(mFixedDamage); }