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