//private WeaponBaseType myWeaponBaseType {
// get {
// if(m_Race != null ) {
// return CommonUtils.Race2WeaponBaseType((Race)m_Race.race);
// }
// return WeaponBaseType.Rocket;
// }
//}
public override WeaponDamage GetDamage(bool isCrit)
{
if (m_Pet)
{
if (m_Pet.info != null)
{
WeaponDamage dmg = new WeaponDamage(myWeaponBaseType);
dmg.SetBaseTypeDamage(m_Pet.info.Damage(nebulaObject.resource.petParameters.damage, nebulaObject.resource.Leveling));
return(dmg);
}
}
return(new WeaponDamage(myWeaponBaseType));
}
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 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);
}
}
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));
}
}
}
}
public void SetBaseDamage(float val)
{
m_Damage.SetBaseTypeDamage(val);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
if (!CheckForShotEnemy(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
float dmg2Mult = skill.data.Inputs.Value <float>("dmg2_mult");
float radius = skill.data.Inputs.Value <float>("radius");
var sourceWeapon = source.GetComponent <BaseWeapon>();
var sourceChar = source.GetComponent <CharacterObject>();
var targetBonuses = source.GetComponent <PlayerTarget>().targetObject.GetComponent <PlayerBonuses>();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
dmg2Mult *= 2;
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
var items = (source.world as MmoWorld).GetItems((it) => {
if (it.GetComponent <DamagableObject>() && it.GetComponent <CharacterObject>())
{
if (it.Id != targetBonuses.nebulaObject.Id)
{
if (sourceChar.RelationTo(it.GetComponent <CharacterObject>()) == FractionRelation.Enemy)
{
return(true);
}
}
}
return(false);
});
float minDist = float.MaxValue;
Item targetItem = null;
foreach (var p in items)
{
float cdist = p.Value.transform.DistanceTo(targetBonuses.transform);
if (cdist < minDist)
{
minDist = cdist;
targetItem = p.Value;
}
}
if (targetItem && (minDist < radius))
{
float dmg = sourceWeapon.GetDamage(false).totalDamage *dmg2Mult;
WeaponDamage sInpWeapDmg = new WeaponDamage(sourceWeapon.myWeaponBaseType);
sInpWeapDmg.SetBaseTypeDamage(dmg);
InputDamage inpDamage = new InputDamage(source, sInpWeapDmg);
targetItem.GetComponent <DamagableObject>().ReceiveDamage(inpDamage);
}
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (!source)
{
return(false);
}
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceWeapon = source.GetComponent <ShipWeapon>();
var sourceCharacter = source.GetComponent <CharacterObject>();
var race = source.GetComponent <RaceableObject>();
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
float secondDmgMult = skill.data.Inputs.Value <float>("second_dmg_mult");
float radius = skill.data.Inputs.Value <float>("radius");
float time = skill.data.Inputs.Value <float>("time");
var targetObject = source.GetComponent <PlayerTarget>().targetObject;
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
secondDmgMult *= 2;
time *= 2;
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
var items = (source.world as MmoWorld).GetItems((it) => {
if (it.GetComponent <DamagableObject>() && it.GetComponent <CharacterObject>())
{
if (it.transform.DistanceTo(targetObject.transform) < radius)
{
if (sourceCharacter.RelationTo(it.GetComponent <CharacterObject>()) == FractionRelation.Enemy)
{
return(true);
}
}
}
return(false);
});
float curTime = Time.curtime();
float damage = sourceWeapon.GetDamage(false).totalDamage *dmgMult;
WeaponDamage wd = new WeaponDamage(sourceWeapon.myWeaponBaseType);
wd.SetBaseTypeDamage(damage);
InputDamage inpDamage = new InputDamage(source, wd);
foreach (var pair in items)
{
if (pair.Value.Id != targetObject.Id)
{
pair.Value.GetComponent <DamagableObject>().ReceiveDamage(inpDamage);
}
sourceWeapon.AddAdditionalDamager(pair.Value.Id, new ShipWeapon.AdditionalDamage {
damageMult = secondDmgMult, expireTime = curTime + time
});
}
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(false);
}
}
