//Check range heal to ally when using skill
protected bool CheckForHealAlly(NebulaObject source)
{
var targetComponent = source.Target();
var weaponComponent = source.Weapon();
var characterComponent = source.Character();
bool allSourceComponentsPresent = targetComponent && weaponComponent && characterComponent;
if (allSourceComponentsPresent)
{
var targetObject = targetComponent.targetObject;
if (targetObject)
{
var targetBonuses = targetObject.Bonuses();
var targetCharacter = targetObject.Character();
var targetDamagable = targetObject.Damagable();
bool allTargetComponentsPresent = targetBonuses && targetCharacter && targetDamagable;
if (allTargetComponentsPresent)
{
var relation = characterComponent.RelationTo(targetCharacter);
if (relation == FractionRelation.Friend)
{
float distanceToTarget = source.transform.DistanceTo(targetObject.transform);
if (distanceToTarget <= weaponComponent.optimalDistance)
{
return(true);
}
}
}
}
}
return(false);
}
protected ConcurrentDictionary <string, Item> GetTargets(NebulaObject source, NebulaObject centerObject, float radius)
{
var sourceCharacter = source.Character();
return(source.mmoWorld().GetItems((item) => {
if (centerObject.transform.DistanceTo(item.transform) < radius)
{
var damagable = item.Damagable();
var bonuses = item.Bonuses();
var character = item.Character();
bool allComponentsPresent = damagable && bonuses && character;
if (allComponentsPresent)
{
if (item.Id != centerObject.Id && (item.Id != source.Id))
{
var relation = sourceCharacter.RelationTo(character);
if (relation == FractionRelation.Enemy || relation == FractionRelation.Neutral)
{
return true;
}
//}
}
}
}
return false;
}));
}
public InputDamage(NebulaObject source, WeaponDamage damage, DamageParams damageParams = null)
{
m_Damager = source;
m_Damage = damage;
if (m_Damager)
{
var sourceCharacter = source.Character();
if (sourceCharacter)
{
m_Workshop = (Workshop)sourceCharacter.workshop;
m_Level = sourceCharacter.level;
}
else
{
m_Workshop = Workshop.Arlen;
m_Level = 1;
}
var sourceRaceable = source.Raceable();
if (sourceRaceable)
{
m_Race = (Race)sourceRaceable.race;
}
else
{
m_Race = Race.None;
}
}
else
{
m_Workshop = Workshop.Arlen;
m_Level = 1;
m_Race = Race.None;
}
m_DamageParams = damageParams;
}
/// <summary>
/// Get items which allowed be targets on healing when used area healing
/// </summary>
/// <param name="source">Who healed</param>
/// <param name="target">What center object</param>
/// <param name="radius">Radius where see items</param>
/// <returns>Return dictionary of founded items</returns>
protected ConcurrentDictionary <string, Item> GetHealTargets(NebulaObject source, NebulaObject target, float radius)
{
var sourceCharacter = source.Character();
return(source.mmoWorld().GetItems((item) => {
float distance = target.transform.DistanceTo(item.transform);
if (distance < radius)
{
var itemDamagable = item.Damagable();
var itemCharacter = item.Character();
var itemBonuses = item.Bonuses();
bool allItemComponentsPresent = itemDamagable && itemCharacter && itemBonuses;
if (allItemComponentsPresent)
{
if (item.Id != target.Id && (item.Id != source.Id))
{
var relation = sourceCharacter.RelationTo(itemCharacter);
if (relation == FractionRelation.Friend)
{
return true;
}
}
}
}
return false;
}));
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
return(false);
}
float dmgMult = skill.GetFloatInput("dmg_mult");
float areaDmgMult = skill.GetFloatInput("dmg_area_mult");
float radius = skill.GetFloatInput("radius");
var weapon = source.Weapon();
var character = source.Character();
var raceable = source.Raceable();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
}
WeaponHitInfo hit;
var shot = weapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
var targets = GetTargets(source, source.Target().targetObject, radius);
var genWeapDmg = weapon.GenerateDamage();
genWeapDmg.Mult(areaDmgMult);
InputDamage inpDamage = new InputDamage(source, genWeapDmg);
if (mastery)
{
//inpDamage.SetDamage(inpDamage.damage * 2);
inpDamage.Mult(2);
}
foreach (var pTarget in targets)
{
pTarget.Value.Damagable().ReceiveDamage(inpDamage);
}
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public float GetLevel(NebulaObject owner)
{
int level = 1;
var character = owner.Character();
if (character != null)
{
level = character.level;
}
return(level);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
float hpPc = skill.data.Inputs.GetValue <float>("hp_pc", 0f);
float hpAlliesPc = skill.data.Inputs.GetValue <float>("hp_allies_pc", 0f);
float hpRestoreTime = skill.data.Inputs.GetValue <float>("hp_pc_time", 0f);
var selfDamagable = source.Damagable();
var selfCharacter = source.Character();
var selfWeapon = source.Weapon();
float selfRestoreHP = selfDamagable.maximumHealth * hpPc;
float alliesRestoreHP = selfDamagable.maximumHealth * hpAlliesPc;
bool mastery = RollMastery(source);
if (mastery)
{
selfRestoreHP *= 2;
alliesRestoreHP *= 2;
}
selfDamagable.SetRestoreHPPerSec(selfRestoreHP / hpRestoreTime, hpRestoreTime, source.Id + skill.data.Id.ToString());
var allies = source.mmoWorld().GetItems(ItemType.Avatar, (item) => {
if (item.Id != source.Id)
{
var character = item.Character();
var damagable = item.Damagable();
if (character && damagable)
{
if (selfCharacter.RelationTo(character) == FractionRelation.Friend)
{
if (item.transform.DistanceTo(source.transform) < selfWeapon.optimalDistance)
{
return(true);
}
}
}
}
return(false);
});
foreach (var friend in allies)
{
friend.Value.Damagable().RestoreHealth(source, alliesRestoreHP);
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
var sourceTarget = source.Target();
bool settedOnTarget = false;
float time = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
}
if (sourceTarget.targetObject)
{
var targetCharacter = sourceTarget.targetObject.Character();
if (targetCharacter)
{
var sourceCharacter = source.Character();
if (sourceCharacter.RelationTo(targetCharacter) == Common.FractionRelation.Friend)
{
var sourceWeapon = source.Weapon();
if (source.transform.DistanceTo(sourceTarget.targetObject.transform) <= sourceWeapon.optimalDistance)
{
var targetBonuses = sourceTarget.targetObject.Bonuses();
if (targetBonuses)
{
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.speed_debuff_immunity, time);
targetBonuses.SetBuff(buff, source);
settedOnTarget = true;
}
}
}
}
}
if (!settedOnTarget)
{
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.speed_debuff_immunity, time);
source.Bonuses().SetBuff(buff, source);
}
return(true);
}
private ConcurrentDictionary <string, Item> GetNearestEnemies(NebulaObject centerObj, NebulaObject myObj, float radius)
{
var myCharacter = myObj.Character();
return(centerObj.mmoWorld().GetItems(item => {
if (item.Character() && item.Damagable() && item.Bonuses())
{
if (centerObj.transform.DistanceTo(item.transform) <= radius)
{
var relation = myCharacter.RelationTo(item.Character());
if (relation == Common.FractionRelation.Enemy || relation == Common.FractionRelation.Neutral)
{
return true;
}
}
}
return false;
}));
}
protected ConcurrentDictionary <string, Item> GetEnemiesAndNeutrals(NebulaObject source, float radius)
{
var sourceCharacter = source.Character();
return(source.mmoWorld().GetItems((item) => {
var damagable = item.Damagable();
var bonuses = item.Bonuses();
var character = item.Character();
bool allComponentsPresent = damagable && bonuses && character;
if (allComponentsPresent)
{
var relation = sourceCharacter.RelationTo(character);
if (relation == FractionRelation.Enemy || relation == FractionRelation.Neutral)
{
return true;
}
}
return false;
}));
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
return(false);
}
float dmgMult = skill.GetFloatInput("dmg_mult");
float dmgAreaMult = skill.GetFloatInput("dmg_area_mult");
float dmgPc = skill.GetFloatInput("dmg_pc");
float dmgTime = skill.GetFloatInput("dmg_time");
int stackCount = skill.GetIntInput("stack_count");
float radius = skill.GetFloatInput("radius");
var sourceWeapon = source.Weapon();
var sourceBonuses = source.Bonuses();
var sourceMessage = source.MmoMessage();
var sourceCharacter = source.Character();
var sourceRace = source.Raceable();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
dmgAreaMult *= 2;
dmgTime *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
sourceMessage.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
var genDmg = sourceWeapon.GenerateDamage();
genDmg.Mult(dmgAreaMult);
InputDamage inpDamage = new InputDamage(source, genDmg);
foreach (var pTarget in GetTargets(source, source.Target().targetObject, radius))
{
pTarget.Value.Damagable().ReceiveDamage(inpDamage);
if (sourceBonuses.GetBuffCountWithTag(Common.BonusType.increase_damage_on_pc, skill.data.Id) < stackCount)
{
Buff buff = new Buff(Guid.NewGuid().ToString(), null, Common.BonusType.increase_damage_on_pc, dmgTime, dmgPc);
buff.SetTag(skill.data.Id);
sourceBonuses.SetBuff(buff, source);
}
}
return(true);
}
else
{
sourceMessage.SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
log.InfoFormat("43F used..");
var sourceWeapon = source.Weapon();
var sourceCharacter = source.Character();
var targetObject = source.Target().targetObject;
if (!targetObject)
{
log.InfoFormat("no target...");
return(false);
}
var targetBonuses = targetObject.Bonuses();
if (!targetBonuses)
{
log.InfoFormat("no bonuses on target...");
return(false);
}
var targetCharacter = targetObject.Character();
if (!targetCharacter)
{
log.InfoFormat("no character on target...");
return(false);
}
var targetDamagable = targetObject.Damagable();
if (!targetDamagable)
{
log.InfoFormat("no damagable on target...");
return(false);
}
var relation = sourceCharacter.RelationTo(targetCharacter);
if (!(relation == Common.FractionRelation.Enemy || relation == Common.FractionRelation.Neutral))
{
log.InfoFormat("relation invalid = {0}", relation);
return(false);
}
float odMult = skill.GetFloatInput("od_mult");
bool mastery = RollMastery(source);
if (mastery)
{
odMult *= 2;
}
float distanceToTarget = source.transform.DistanceTo(targetObject.transform);
float limitDistance = sourceWeapon.optimalDistance * odMult;
log.InfoFormat("distance to target = {0}, limit distance = {1}", distanceToTarget, limitDistance);
if (distanceToTarget > limitDistance)
{
return(false);
}
var direction = source.transform.DirectionTo(targetObject.transform) * sourceWeapon.optimalDistance * 0.05f;
var newPos = source.transform.position + direction;
if (targetObject.IsPlayer())
{
targetObject.MmoMessage().SetPos(newPos);
}
else
{
(targetObject as Item).Move(new GameMath.Vector {
X = newPos.X, Y = newPos.Y, Z = newPos.Z
});
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var targ = source.Target().targetObject;
var sourceCharacter = source.Character();
var sourceWeapon = source.Weapon();
var message = source.GetComponent <MmoMessageComponent>();
float dmgMult = skill.GetFloatInput("dmg_mult");
float radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
radius *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
BonusType[] speedDebuffs = BuffUtils.GetDebuffsForParameter(BuffParameter.speed);
if (hit.normalOrMissed)
{
message.SendShot(EventReceiver.OwnerAndSubscriber, shot);
var items = source.mmoWorld().GetItems((item) => {
var itemBonuses = item.Bonuses();
var itemCharacter = item.Character();
var itemDamagable = item.Damagable();
bool allComponentPresent = itemBonuses && itemCharacter && itemDamagable;
if (allComponentPresent)
{
if (item.Id != targ.Id)
{
float distanceToTarg = targ.transform.DistanceTo(item.transform);
if (distanceToTarg <= radius)
{
if (itemBonuses.ContainsAny(speedDebuffs))
{
var relation = sourceCharacter.RelationTo(itemCharacter);
if (relation == FractionRelation.Enemy || relation == FractionRelation.Neutral)
{
return(true);
}
}
}
}
}
return(false);
});
foreach (var pitem in items)
{
WeaponHitInfo itemHit;
var itemShot = sourceWeapon.Fire(pitem.Value, out itemHit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
message.SendShot(EventReceiver.OwnerAndSubscriber, itemShot);
}
else
{
message.SendShot(EventReceiver.OwnerAndSubscriber, shot);
}
}
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
var weapon = source.Weapon();
var targets = GetTargets(source, source, weapon.optimalDistance);
if (targets.Count == 0)
{
return(false);
}
ConcurrentBag <Item> filteredTargets = new ConcurrentBag <Item>();
foreach (var pItem in targets)
{
filteredTargets.Add(pItem.Value);
if (filteredTargets.Count >= 3)
{
break;
}
}
float dmgMult = skill.GetFloatInput("dmg_mult");
float dmgAreaMult = skill.GetFloatInput("dmg_area_mult");
float radius = skill.GetFloatInput("radius");
float damagePerTarget = dmgMult / filteredTargets.Count;
var sourceMessage = source.MmoMessage();
var sourceCharacter = source.Character();
var sourceRace = source.Raceable();
bool mastery = RollMastery(source);
if (mastery)
{
damagePerTarget *= 2;
dmgAreaMult *= 2;
}
foreach (var target in filteredTargets)
{
WeaponHitInfo hit;
var shot = weapon.Fire(target, out hit, skill.data.Id, damagePerTarget);
if (hit.normalOrMissed)
{
sourceMessage.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
var nearItems = GetTargets(source, target, radius);
WeaponDamage wd = weapon.GenerateDamage();
wd.Mult(dmgAreaMult);
InputDamage inpDamage = new InputDamage(source, wd);
foreach (var pNear in nearItems)
{
if (NoId(filteredTargets, pNear.Key))
{
pNear.Value.Damagable().ReceiveDamage(inpDamage);
}
}
}
else
{
sourceMessage.SendShot(Common.EventReceiver.ItemOwner, shot);
}
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
var targetObject = source.Target().targetObject;
if (!targetObject)
{
return(false);
}
var weapon = source.Weapon();
if (Mathf.Approximately(weapon.HitProbTo(targetObject), 0f))
{
log.InfoFormat("Skill {0} error: hit prob is 0", skill.data.Id.ToString("X8"));
return(false);
}
float dmgMult = skill.GetFloatInput("dmg_mult");
float critChanceForBot = skill.GetFloatInput("crit_chance");
float maxCrit = skill.GetFloatInput("max_crit");
float time = skill.GetFloatInput("time");
float radius = skill.GetFloatInput("radius");
var character = source.Character();
var targets = source.mmoWorld().GetItems((item) => {
var damagable = item.Damagable();
var itemCharacter = item.Character();
if (damagable && itemCharacter)
{
var relation = character.RelationTo(itemCharacter);
if (relation == FractionRelation.Enemy || relation == FractionRelation.Neutral)
{
if (targetObject.transform.DistanceTo(item.transform) <= radius)
{
return(true);
}
}
}
return(false);
});
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
time *= 2;
}
foreach (var pTarget in targets)
{
WeaponHitInfo hit;
var shot = weapon.Fire(pTarget.Value, out hit, skill.data.Id, dmgMult, forceShot: true);
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shot);
}
float critChanceBuffValue = Mathf.Clamp(targets.Count * critChanceForBot, 0, maxCrit);
if (!Mathf.Approximately(0f, critChanceBuffValue))
{
Buff buff = new Buff(skill.data.Id.ToString(), null, BonusType.increase_crit_chance_on_cnt, time, critChanceBuffValue);
source.Bonuses().SetBuff(buff, source);
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
float odMult = skill.GetFloatInput("od_mult");
bool mastery = RollMastery(source);
if (mastery)
{
odMult *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
var sourceTarget = source.Target();
if (sourceTarget.targetObject)
{
var targetObject = sourceTarget.targetObject;
var targetCharacter = targetObject.Character();
if (targetCharacter)
{
var relation = source.Character().RelationTo(targetCharacter);
if (relation == Common.FractionRelation.Friend)
{
var sourceWeapon = source.Weapon();
if (source.transform.DistanceTo(targetObject.transform) <= odMult * sourceWeapon.optimalDistance)
{
source.MmoMessage().StartJumpToPosition(targetObject.transform.position, skill.data.Id);
return(true);
}
else
{
info.SetSkillUseState(SkillUseState.tooFar);
}
}
else
{
info.SetSkillUseState(SkillUseState.invalidTarget);
}
}
else
{
info.SetSkillUseState(SkillUseState.invalidTarget);
}
}
else
{
info.SetSkillUseState(SkillUseState.invalidTarget);
}
return(false);
}
private NebulaObject GetNearestFriend(NebulaObject centerObj, NebulaObject myObj, float radius)
{
var centerCharacter = centerObj.Character();
var myCharacter = myObj.Character();
var playerItems = centerObj.mmoWorld().GetItems(item => {
if (item.getItemType() == Common.ItemType.Avatar)
{
if (myCharacter.RelationTo(item.Character()) == Common.FractionRelation.Friend)
{
if (item.Id != myObj.Id && item.Id != centerObj.Id)
{
return(true);
}
}
}
return(false);
});
Item nearestPlayerItem = null;
float curDist = float.MaxValue;
foreach (var kvp in playerItems)
{
float dist = kvp.Value.transform.DistanceTo(centerObj.transform);
if (dist < curDist)
{
nearestPlayerItem = kvp.Value;
curDist = dist;
}
}
if (curDist <= radius)
{
if (nearestPlayerItem != null)
{
return(nearestPlayerItem);
}
}
var nonPlayerItems = centerObj.mmoWorld().GetItems(item => {
if (item.getItemType() != Common.ItemType.Avatar)
{
var itemCharacter = item.Character();
var itemDamagable = item.Damagable();
var itemBonuses = item.Bonuses();
if (itemCharacter && itemDamagable && itemBonuses)
{
if (item.Id != myObj.Id && item.Id != centerObj.Id)
{
if (myCharacter.RelationTo(itemCharacter) == Common.FractionRelation.Friend)
{
return(true);
}
}
}
}
return(false);
});
Item nearestNonPlayerItem = null;
curDist = float.MaxValue;
foreach (var kvp in nonPlayerItems)
{
float dist = centerObj.transform.DistanceTo(kvp.Value.transform);
if (dist < curDist)
{
nearestNonPlayerItem = kvp.Value;
curDist = dist;
}
}
if (curDist <= radius)
{
return(nearestNonPlayerItem);
}
return(null);
}
private float ComputeMissProb(NebulaObject targetObject)
{
//if target either planet obj or turret or drill we don't use level difference miss
if (targetObject.Type == (byte)ItemType.Bot)
{
var botComp = targetObject.GetComponent <BotObject>();
if (botComp != null)
{
BotItemSubType subType = (BotItemSubType)botComp.botSubType;
switch (subType)
{
case BotItemSubType.PlanetBuilding:
case BotItemSubType.Turret:
case BotItemSubType.Drill:
if (nebulaObject.Type == (byte)ItemType.Avatar)
{
log.InfoFormat("your attacked {0}, miss prob %", subType);
}
return(0);
}
}
}
//if source planet obj or drill or turret we don't use level difference miss
if (nebulaObject.Type == (byte)ItemType.Bot)
{
if (m_CachedBot != null)
{
BotItemSubType subType = (BotItemSubType)m_CachedBot.botSubType;
switch (subType)
{
case BotItemSubType.Drill:
case BotItemSubType.PlanetBuilding:
case BotItemSubType.Turret:
return(0);
}
}
}
var targetCharacter = targetObject.Character();
if (!targetCharacter)
{
return(0f);
}
int myLevel = cachedCharacter.level;
int targetLevel = targetCharacter.level;
int diff = myLevel - targetLevel;
if (diff >= 0)
{
return(0f);
}
switch (Mathf.Abs(diff))
{
case 1:
return(0.01f);
case 2:
return(0.05f);
case 3:
return(0.15f);
case 4:
return(0.25f);
case 5:
return(0.4f);
}
return(0.6f);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
float dmgMult = skill.GetFloatInput("dmg_mult");
float dmgTimedMult = skill.GetFloatInput("dmg_timed_mult");
float time = skill.GetFloatInput("time");
var sourceCharacter = source.Character();
var sourceRaceable = source.Raceable();
info.SetSkillUseState(SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
WeaponHitInfo hit;
var sourceWeapon = source.Weapon();
float baseDamage = sourceWeapon.GetDamage().totalDamage;
float timedDamage = baseDamage * dmgTimedMult;
//float secondDamage = baseDamage * dmgAreaMult;
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
timedDamage *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
var shot = source.Weapon().Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
source.Target().targetObject.Damagable().SetTimedDamage(time, timedDamage / time, sourceWeapon.myWeaponBaseType, skill.idInt);
/*
* WeaponDamage sInpWeapDmg = new WeaponDamage(sourceWeapon.myWeaponBaseType);
* sInpWeapDmg.SetBaseTypeDamage(secondDamage);
* InputDamage inpDamage = new InputDamage(source, sInpWeapDmg);
* if(mastery) {
* inpDamage.Mult(2);
* //inpDamage.SetDamage(inpDamage.damage * 2);
* }
* foreach(var pitem in GetTargets(source, source.Target().targetObject, radius)) {
* pitem.Value.Damagable().ReceiveDamage(inpDamage);
* }*/
return(true);
}
return(false);
}
