public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
float dmgMult = skill.GetFloatInput("dmg_mult");
float hpMult = skill.GetFloatInput("hp_mult");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hpMult *= 2;
}
WeaponHitInfo hit;
var shot = source.Weapon().Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
float hp = hit.actualDamage.totalDamage * hpMult;
source.Damagable().RestoreHealth(source, hp);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
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 override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
var targetDamagable = targetObject.Damagable();
float damageMult = skill.GetFloatInput("dmg_mult");
float hpPc = skill.GetFloatInput("hp_pc");
float hpRestoredPc = skill.GetFloatInput("hp_restored_pc");
bool targetHpLow = true;
if (targetDamagable.health > targetDamagable.maximumHealth * hpPc)
{
targetHpLow = false;
}
if (!targetHpLow)
{
damageMult = 1;
}
bool mastery = RollMastery(source);
if (mastery)
{
damageMult *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, damageMult);
if (hit.normalOrMissed)
{
if (targetDamagable.killed)
{
float resotedHp = source.Damagable().maximumHealth *hpRestoredPc;
if (mastery)
{
resotedHp *= 2;
}
source.Damagable().RestoreHealth(source, resotedHp);
}
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
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 hpPc = skill.GetFloatInput("hp_pc");
float radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hpPc *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
float hpVal = source.Damagable().maximumHealth *hpPc;
WeaponHitInfo hit;
var shot = source.Weapon().Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
//Buff speedBuff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_speed_on_pc, speedTime, speedPc);
//source.Bonuses().SetBuff(speedBuff, source);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
var sWeapon = source.Weapon();
var mmoMsg = source.MmoMessage();
foreach (var friend in GetNearestFriends(source, radius))
{
var heal = sWeapon.Heal(friend.Value, hpVal, skill.idInt);
mmoMsg.SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
}
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 speedPc = skill.GetFloatInput("speed_pc");
float speedTime = skill.GetFloatInput("speed_time");
float radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
speedTime *= 2;
}
var sourceWeapon = source.Weapon();
var sourceBonuses = source.Bonuses();
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_speed_on_pc, speedTime, speedPc);
sourceBonuses.SetBuff(buff, source);
foreach (var ally in GetHealTargets(source, source, radius))
{
Buff buff2 = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_speed_on_pc, speedTime, speedPc);
ally.Value.Bonuses().SetBuff(buff2, source);
}
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
ResetCounter();
return(false);
}
var dmgMult = skill.GetFloatInput("dmg_mult");
var hpPc = skill.GetFloatInput("hp_pc");
var hpTime = skill.GetFloatInput("hp_time");
mUseCounter++;
if (source.Skills().lastSkill != skill.data.Id)
{
mUseCounter = 0;
}
mUseCounter = Mathf.Clamp(mUseCounter, 0, 2);
dmgMult = ModifyDamageMult(dmgMult);
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hpTime *= 2;
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
Buff buff = new Buff(skill.id, null, Common.BonusType.increase_healing_speed_on_pc, hpTime, hpPc);
source.Bonuses().SetBuff(buff, source);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
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 blockProb = skill.GetFloatInput("block_prob");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
blockProb *= 2;
}
WeaponHitInfo hit;
var shot = source.Weapon().Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
var targetWeapon = source.Target().targetObject.Weapon();
if (targetWeapon)
{
if (Rand.Float01() < blockProb)
{
targetWeapon.BlockSingleShot();
}
}
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
if (!source)
{
return(false);
}
var damagable = source.GetComponent <DamagableObject>();
if (!damagable)
{
return(false);
}
float hpPc = skill.GetFloatInput("hp_pc");
float hp = hpPc * damagable.maximumHealth;
//damagable.SetHealth(damagable.health + hp);
bool mastery = RollMastery(source);
if (mastery)
{
hp *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
//damagable.RestoreHealth(source, hp);
//source.Weapon().HealSelf(hp, skill.idInt);
source.MmoMessage().SendHeal(EventReceiver.OwnerAndSubscriber, source.Weapon().HealSelf(hp, skill.idInt));
return(true);
}
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 dmgPc = skill.GetFloatInput("dmg_pc");
float dmgTime = skill.GetFloatInput("dmg_time");
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
var targetBonuses = targetObject.Bonuses();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
dmgTime *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.decrease_damage_on_pc, dmgTime, dmgPc);
targetBonuses.SetBuff(buff, source);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var targetObject = source.Target().targetObject;
var sourceWeapon = source.Weapon();
var sourceBonuses = source.Bonuses();
WeaponHitInfo hit;
float dmgMult = skill.GetFloatInput("dmg_mult");
float speedPc = skill.GetFloatInput("speed_pc");
float speedTime = skill.GetFloatInput("speed_time");
float radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
speedTime *= 2;
}
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
var items = GetTargets(source, targetObject, radius);
foreach (var pItem in items)
{
var item = pItem.Value;
var itemBonuses = item.Bonuses();
Buff speedDebuff = new Buff(skill.id, null, Common.BonusType.decrease_speed_on_pc, speedTime, speedPc);
itemBonuses.SetBuff(speedDebuff, source);
}
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
float dmgMult = skill.GetFloatInput("dmg_mult");
if (RollMastery(source))
{
dmgMult *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
string id = source.Id + skill.data.Id;
WeaponHitInfo hit;
var sourceWeapon = source.Weapon();
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
source.MmoMessage().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
source.MmoMessage().SendShot(EventReceiver.ItemOwner, shotInfo);
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);
}
var targetObject = source.Target().targetObject;
var sourceWeapon = source.Weapon();
var sourceBonuses = source.Bonuses();
WeaponHitInfo hit;
float dmgMult = skill.GetFloatInput("dmg_mult");
float hpPc = skill.GetFloatInput("hp_pc");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hpPc *= 2;
}
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
sourceWeapon.Heal(source, source.Damagable().maximumHealth *hpPc);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
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 radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
radius *= 2;
}
BaseWeapon sourceWeapon = source.Weapon();
MmoMessageComponent message = source.MmoMessage();
NebulaObject targetObject = source.Target().targetObject;
WeaponHitInfo hit;
Hashtable shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
message.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
ConcurrentDictionary <string, Item> targets = GetTargets(source, targetObject, radius);
int counter = 0;
foreach (var pTarget in targets)
{
var shot2 = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
message.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot2);
counter++;
if (counter == 2)
{
break;
}
}
return(true);
}
else
{
message.SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
float damageMult = skill.GetFloatInput("dmg_mult");
bool mastery = RollMastery(source);
if (mastery)
{
damageMult *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, damageMult);
if (hit.normalOrMissed)
{
Vector3 center = (source.transform.position + targetObject.transform.position) * 0.5f;
float radius = source.transform.DistanceTo(targetObject.transform) * 0.5f;
var skillComponent = source.GetComponent <Skill_0000045E_Component>();
if (skillComponent == null)
{
skillComponent = source.AddComponent <Skill_0000045E_Component>();
}
skillComponent.SetSkill(center, radius, skill.data);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
float healMult = skill.GetFloatInput("heal_mult");
float radius = skill.GetFloatInput("radius");
var weapon = source.Weapon();
float damage = weapon.GetDamage(false).totalDamage;
float totalHealing = healMult * damage;
var items = GetNearestFriends(source, radius); //GetHealTargets(source, source, radius);
//if(items.Count == 0 ) {
// return false;
//}
int count = items.Count;
if (count == 0)
{
count = 1;
}
float healPerItem = totalHealing / items.Count;
bool mastery = RollMastery(source);
if (mastery)
{
healPerItem *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
var message = source.MmoMessage();
foreach (var pitem in items)
{
var heal = weapon.Heal(pitem.Value, healPerItem, skill.data.Id);
message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
var targetBonuses = targetObject.Bonuses();
float dmgMult = skill.GetFloatInput("dmg_mult");
float hpPc = skill.GetFloatInput("hp_pc");
float hpTime = skill.GetFloatInput("hp_time");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hpTime *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
Buff buff = new Buff(skill.id, null, Common.BonusType.decrease_max_hp_on_pc, hpTime, hpPc);
targetBonuses.SetBuff(buff, source);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
else
{
source.MmoMessage().SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var targetObject = source.Target().targetObject;
var sourceWeapon = source.Weapon();
var sourceMessage = source.MmoMessage();
float dmgMult = skill.GetFloatInput("dmg_mult");
float dmgAreaMult = skill.GetFloatInput("dmg_area_mult");
float radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
dmgAreaMult *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
sourceMessage.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
var items = GetTargets(source, targetObject, radius);
foreach (var pItem in items)
{
var item = pItem.Value;
WeaponHitInfo hit2;
var shot2 = sourceWeapon.Fire(item, out hit2, skill.data.Id, dmgAreaMult);
if (hit2.normalOrMissed)
{
sourceMessage.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot2);
}
}
return(true);
}
else
{
sourceMessage.SendShot(Common.EventReceiver.ItemOwner, shot);
return(false);
}
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
bool result = base.TryCast(source, skill, out info);
if (result)
{
var damagable = source.Damagable();
float hpPc = skill.GetFloatInput("hp_pc");
bool mastery = RollMastery(source);
if (mastery)
{
hpPc *= 2;
}
//damagable.RestoreHealth(source, damagable.maximumHealth * hpPc);
var heal = source.Weapon().HealSelf(damagable.maximumHealth * hpPc, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
}
return(result);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
var targetDamagable = targetObject.Damagable();
var sourceMessage = source.MmoMessage();
float dmgMult = skill.GetFloatInput("dmg_mult");
float timedDmgMult = skill.GetFloatInput("timed_dmg_mult");
float timedDmgTime = skill.GetFloatInput("dmg_time");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
var timedDamage = sourceWeapon.GenerateDamage().totalDamage *timedDmgMult / timedDmgTime;
targetDamagable.SetTimedDamage(timedDmgTime, timedDamage, sourceWeapon.myWeaponBaseType, skill.idInt);
sourceMessage.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
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();
info.SetSkillUseState(Common.SkillUseState.normal);
float hpPc = skill.GetFloatInput("hp_pc");
float hpPcTimed = skill.GetFloatInput("hp_pc_timed");
float hpTime = skill.GetFloatInput("hp_time");
var damagable = source.Damagable();
float maxHealth = damagable.maximumHealth;
float hpInstance = hpPc * maxHealth;
float hpRestorePerSec = hpPcTimed * maxHealth / hpTime;
string id = source.Id + skill.data.Id.ToString();
bool mastery = RollMastery(source);
if (mastery)
{
hpInstance *= 2;
hpTime *= 2;
hpRestorePerSec *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
//damagable.RestoreHealth(source, hpInstance);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, source.Weapon().HealSelf(hpInstance, skill.idInt));
damagable.SetRestoreHPPerSec(hpRestorePerSec, hpTime, id);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
bool castOnTarget = true;
if (source.Target().hasTarget)
{
if (FriendTargetInvalid(source))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
//return false;
castOnTarget = false;
}
else
{
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
//return false;
}
castOnTarget = false;
}
}
else
{
castOnTarget = false;
}
float healMult = skill.GetFloatInput("heal_mult");
var weapon = source.Weapon();
float damage = weapon.GetDamage().totalDamage;
float healValue = damage * healMult;
bool mastery = RollMastery(source);
if (mastery)
{
healValue *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
if (castOnTarget)
{
//firtst heal friend
var heal = source.Weapon().Heal(source.Target().targetObject, healValue, skill.data.Id);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
}
//second heal self
var selfHeal = source.Weapon().HealSelf(healValue, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, selfHeal);
return(true);
}
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();
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);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
float hp_pc = skill.data.Inputs.Value <float>("hp_pc");
float hp_radius = skill.data.Inputs.Value <float>("hp_radius");
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
var sourceWeapon = source.GetComponent <BaseWeapon>();
var sourceChar = source.GetComponent <CharacterObject>();
var sourceDamagable = source.GetComponent <DamagableObject>();
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
hp_pc *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.GetComponent <BaseWeapon>().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 (source.transform.DistanceTo(it.transform) <= hp_radius)
{
if (sourceChar.RelationTo(it.GetComponent <CharacterObject>()) == FractionRelation.Friend)
{
return(true);
}
}
}
return(false);
});
float hp = hp_pc * sourceDamagable.maximumHealth;
var sourceMmoMessage = source.MmoMessage();
foreach (var p in items)
{
/*
* var d = p.Value.GetComponent<DamagableObject>();
* d.RestoreHealth(source, hp);*/
//d.SetHealth(d.health + hp);
var heal = sourceWeapon.Heal(p.Value, hp, skill.idInt);
sourceMmoMessage.SendHeal(EventReceiver.OwnerAndSubscriber, heal);
info.Add(p.Value.Id, p.Value.Type);
}
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();
info.SetSkillUseState(SkillUseState.normal);
if (ShotToEnemyRestricted(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
var sourceWeapon = source.Weapon();
var sourceTarget = source.Target();
var targetBonuses = sourceTarget.targetObject.Bonuses();
if (!sourceTarget)
{
return(false);
}
if (!sourceTarget.targetObject)
{
return(false);
}
var targetShip = sourceTarget.targetObject.GetComponent <BaseShip>();
if (!targetShip)
{
return(false);
}
float targetResistance = sourceTarget.targetObject.GetComponent <BaseShip>().commonResist;
float dmgMult = skill.GetFloatInput("dmg_mult");
float resistTime = skill.GetFloatInput("resist_time");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
resistTime *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
WeaponHitInfo hit;
var shot = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
Buff resistDebuff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.decrease_resist_on_cnt, resistTime, targetResistance);
targetBonuses.SetBuff(resistDebuff, source);
source.MmoMessage().SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
return(true);
}
return(false);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
//if(!CheckForHealAlly(source)) {
// info.SetSkillUseState(Common.SkillUseState.invalidTarget);
// return false;
//}
//if(NotCheckDistance(source)) {
// info.SetSkillUseState(Common.SkillUseState.tooFar);
// return false;
//}
if (!source)
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
return(false);
}
float healMult = skill.GetFloatInput("heal_mult");
float healAreaMult = skill.GetFloatInput("area_heal");
float radius = skill.GetFloatInput("radius");
float damage = source.Weapon().GetDamage().totalDamage;
float selfHeal = damage * healMult;
float areaHeal = damage * healAreaMult;
bool mastery = RollMastery(source);
if (mastery)
{
info.SetMastery(true);
selfHeal *= 2;
areaHeal *= 2;
}
else
{
info.SetMastery(false);
}
var weapon = source.Weapon();
var message = source.MmoMessage();
foreach (var friend in GetNearestFriends(source, radius))
{
if (friend.Value.Id == source.Id)
{
message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, weapon.HealSelf(selfHeal, skill.idInt));
}
else
{
message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, weapon.Heal(friend.Value, areaHeal, skill.idInt));
}
}
return(true);
/*
* var weapon = source.Weapon();
* var heal = weapon.Heal(source.Target().targetObject, targetHeal, skill.data.Id);
*
* var message = source.MmoMessage();
* message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
*
* var items = GetHealTargets(source, source.Target().targetObject, radius);
* foreach(var pitem in items) {
* var additionalHeal = weapon.Heal(pitem.Value, areaHeal);
* message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, additionalHeal);
* }
* return true;*/
}
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);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
bool castOnTarget = true;
if (source.Target().hasTarget)
{
if (FriendTargetInvalid(source))
{
castOnTarget = false;
}
else
{
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
return(false);
}
}
}
else
{
castOnTarget = false;
}
float radius = skill.GetFloatInput("radius");
float healMult = skill.GetFloatInput("heal_mult");
float dmgMult = skill.GetFloatInput("dmg_mult");
bool mastery = RollMastery(source);
if (mastery)
{
healMult *= 2;
dmgMult *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
NebulaObject enemyCenterObj = null;
float healVal = source.Weapon().GetDamage().totalDamage;
if (castOnTarget)
{
var tObj = source.Target().targetObject;
var heal = source.Weapon().Heal(tObj, healMult * healVal, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
var nearestFriend = GetNearestFriend(tObj, source, radius);
info.Add((int)SPC.Var1, new Hashtable {
{ (int)SPC.ItemId, tObj.Id }, { (int)SPC.ItemType, tObj.Type }
});
if (nearestFriend != null)
{
heal = source.Weapon().Heal(nearestFriend, healMult * healVal, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
info.Add((int)SPC.Var2, new Hashtable {
{ (int)SPC.ItemId, nearestFriend.Id }, { (int)SPC.ItemType, nearestFriend.Type }
});
}
enemyCenterObj = source.Target().targetObject;
}
else
{
var heal = source.Weapon().HealSelf(healVal, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
info.Add((int)SPC.Var1, new Hashtable {
{ (int)SPC.ItemId, source.Id }, { (int)SPC.ItemType, source.Type }
});
var nearestFriend = GetNearestFriend(source, source, radius);
if (nearestFriend != null)
{
heal = source.Weapon().Heal(nearestFriend, healMult * healVal, skill.idInt);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
info.Add((int)SPC.Var2, new Hashtable {
{ (int)SPC.ItemId, nearestFriend.Id }, { (int)SPC.ItemType, nearestFriend.Type }
});
}
enemyCenterObj = source;
}
var sWeapon = source.Weapon();
var sMessage = source.MmoMessage();
foreach (var enemy in GetNearestEnemies(enemyCenterObj, source, radius))
{
WeaponHitInfo hit;
var fire = sWeapon.Fire(enemy.Value, out hit, skill.idInt, dmgMult);
sMessage.SendShot(Common.EventReceiver.OwnerAndSubscriber, fire);
log.InfoFormat("send fire to object {0}->{1}".Olive(), enemy.Value.Id, enemy.Value.getItemType());
}
//var weapon = source.Weapon();
//var message = source.MmoMessage();
//var targetObject = source.Target().targetObject;
//var healValue = weapon.GetDamage(false).totalDamage * healMult;
//var firstHeal = weapon.Heal(targetObject, healValue, skill.data.Id);
//message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, firstHeal);
//var healTargets = GetHealTargets(source, targetObject, radius);
//foreach(var pHealTarget in healTargets) {
// var secondHeal = weapon.Heal(pHealTarget.Value, healValue, skill.data.Id);
// message.SendHeal(Common.EventReceiver.OwnerAndSubscriber, secondHeal);
// break;
//}
//var dmgTargets = GetTargets(source, targetObject, radius);
//foreach(var pDmgTarget in dmgTargets) {
// WeaponHitInfo hit;
// var shot = weapon.Fire(pDmgTarget.Value, out hit, skill.data.Id, dmgMult);
// message.SendShot(Common.EventReceiver.OwnerAndSubscriber, shot);
//}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
bool castOnTarget = true;
if (source.Target().hasTarget)
{
if (FriendTargetInvalid(source))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
//return false;
castOnTarget = false;
}
else
{
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
//return false;
castOnTarget = false;
}
}
}
else
{
castOnTarget = false;
}
float healMult = skill.GetFloatInput("heal_mult");
float resistPc = skill.GetFloatInput("resist_pc");
float resistTime = skill.GetFloatInput("resist_time");
float damage = source.Weapon().GetDamage().totalDamage;
float healing = damage * healMult;
bool mastery = RollMastery(source);
if (mastery)
{
healing *= 2;
resistTime *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
NebulaObject targetObject = null;
if (castOnTarget)
{
targetObject = source.Target().targetObject;
var heal = source.Weapon().Heal(targetObject, healing, skill.data.Id);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal);
Buff resistBuff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_resist_on_cnt, resistTime, resistPc);
targetObject.Bonuses().SetBuff(resistBuff, source);
}
targetObject = source;
var heal2 = source.Weapon().Heal(targetObject, healing, skill.data.Id);
source.MmoMessage().SendHeal(Common.EventReceiver.OwnerAndSubscriber, heal2);
Buff resistBuff2 = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_resist_on_cnt, resistTime, resistPc);
targetObject.Bonuses().SetBuff(resistBuff2, source);
return(true);
}
