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