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();
var targetObject = source.Target().targetObject;
if (!targetObject)
{
return(false);
}
float moveDmgPc = skill.GetFloatInput("move_dmg_pc");
float time = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
}
if (targetObject.IsPlayer() && targetObject.Raceable().race == source.Raceable().race)
{
if (source.transform.DistanceTo(targetObject.transform) <= source.Weapon().optimalDistance)
{
source.Skills().Set404(time, moveDmgPc);
info.Add((int)SPC.Id, targetObject.Id);
return(true);
}
}
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);
}
//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);
}
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 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 (!source)
{
log.InfoFormat("Skill {0} error: source invalid", skill.data.Id.ToString("X8"));
return(false);
}
float buffDamagePercent = skill.data.Inputs.Value <float>("b_dmg_pc");
float buffDamageInterval = skill.data.Inputs.Value <float>("b_dmg_interval");
float damageMult = skill.data.Inputs.Value <float>("dmg_mult");
string id = source.Id + skill.data.Id;
info.SetSkillUseState(SkillUseState.normal);
if (!CheckForShotEnemy(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
bool mastery = RollMastery(source);
if (mastery)
{
damageMult *= 2;
}
WeaponHitInfo hit;
var shotInfo = source.Weapon().GetComponent <BaseWeapon>().Fire(out hit, skill.data.Id, damageMult);
if (hit.normalOrMissed)
{
if (mastery)
{
buffDamageInterval *= 2;
}
Buff damageBuff = new Buff(id, null, BonusType.increase_damage_on_pc, buffDamageInterval, buffDamagePercent);
source.GetComponent <PlayerBonuses>().SetBuff(damageBuff, source);
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
log.InfoFormat("Skill {0} error: hit to target not allowed", skill.data.Id.ToString("X8"));
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();
info.SetSkillUseState(SkillUseState.normal);
if (!CheckForShotEnemy(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
var sourceWeapon = source.Weapon();
float dmgMult = skill.GetFloatInput("dmg_mult");
float blockTime = skill.GetFloatInput("block_time");
bool mastery = RollMastery(source);
if (mastery)
{
dmgMult *= 2;
blockTime *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
WeaponHitInfo hit;
var shotInfo = sourceWeapon.Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
var targetObject = source.Target().targetObject;
Buff debuff = new Buff(skill.data.Id.ToString(), null, BonusType.block_skills, blockTime, 1.0f);
targetObject.Bonuses().SetBuff(debuff, source);
targetObject.Skills().Block(blockTime);
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
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);
}
}
//private static readonly ILogger log = LogManager.GetCurrentClassLogger();
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
//log.Info("USE 3E9");
info = new Hashtable();
float decreaseSpeedPercent = skill.data.Inputs.Value <float>("decrease_speed_pc");
float dmgMult = skill.data.Inputs.Value <float>("dmg_mult");
string id = source.Id + skill.data.Id;
info.SetSkillUseState(SkillUseState.normal);
if (!CheckForShotEnemy(source, skill))
{
info.SetSkillUseState(SkillUseState.invalidTarget);
return(false);
}
if (NotCheckDistance(source))
{
info.SetSkillUseState(SkillUseState.tooFar);
return(false);
}
if (RollMastery(source))
{
dmgMult *= 2;
}
WeaponHitInfo hit;
var sourceWeapon = source.Weapon();
var targetBonuses = source.Target().targetObject.Bonuses();
var shotInfo = sourceWeapon.GetComponent <BaseWeapon>().Fire(out hit, skill.data.Id, dmgMult);
if (hit.normalOrMissed)
{
//log.Info("HIT ALLOWED");
float speedCount = source.GetComponent <MovableObject>().normalSpeed *decreaseSpeedPercent;
Buff speedDebuff = new Buff(id, null, BonusType.decrease_speed_on_cnt, skill.data.Durability, speedCount);
targetBonuses.SetBuff(speedDebuff, source);
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
return(true);
}
else
{
log.Info("HIT NOT ALLOWED");
source.GetComponent <MmoMessageComponent>().SendShot(EventReceiver.OwnerAndSubscriber, shotInfo);
log.InfoFormat("Skill {0} error: hit to target not allowed", skill.data.Id.ToString("X8"));
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();
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)
{
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();
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(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();
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);
}
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)
{
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 void Make(NebulaObject source, PlayerSkill skill, float hpPc)
{
float radius = skill.GetFloatInput("radius");
/*
* var items = GetHealTargets(source, source, skill.GetFloatInput("radius"));
* float restoredHp = hpPc * source.Weapon().GetDamage(false).totalDamage;
*
* foreach(var pItem in items) {
* pItem.Value.Damagable().RestoreHealth(source, restoredHp);
* }*/
var weapon = source.Weapon();
float hp = weapon.GetDamage().totalDamage *hpPc;
foreach (var pFriend in GetNearestFriends(source, radius))
{
weapon.Heal(pFriend.Value, hp, skill.idInt, generateCrit: 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 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 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();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
float speedPc = skill.GetFloatInput("speed_pc");
float speedTime = skill.GetFloatInput("speed_time");
float dmgPc = skill.GetFloatInput("dmg_pc");
bool mastery = RollMastery(source);
if (mastery)
{
dmgPc *= 2;
speedPc *= 2;
}
var sourceWeapon = source.Weapon();
var targetObject = source.Target().targetObject;
var targetBonuses = targetObject.Bonuses();
Buff speedDebuff = new Buff(skill.id, null, Common.BonusType.decrease_speed_on_pc, speedTime, speedPc);
targetBonuses.SetBuff(speedDebuff, source);
var targetDamagable = targetObject.Damagable();
float damage = sourceWeapon.GenerateDamage().totalDamage *dmgPc;
targetDamagable.SetTimedDamage(speedTime, damage, sourceWeapon.myWeaponBaseType, skill.idInt);
info.Add((int)SPC.Damage, damage);
source.SetInvisibility(false);
return(true);
}
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))
{
castOnTarget = false;
}
else
{
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
return(false);
}
}
}
else
{
castOnTarget = false;
}
float dmgMult = skill.GetFloatInput("dmg_mult");
var weapon = source.Weapon();
float damage = weapon.GetDamage().totalDamage;
float absorbedDamage = dmgMult * damage;
//NebulaObject target = null;
//if(CheckForHealAlly(source)) {
// target = source.Target().targetObject;
//} else {
// target = source;
//}
bool mastery = RollMastery(source);
if (mastery)
{
absorbedDamage *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
if (castOnTarget)
{
source.Target().targetObject.Bonuses().SetAbsrobBuff(absorbedDamage, source);
}
else
{
source.Bonuses().SetAbsrobBuff(absorbedDamage, source);
}
//target.Damagable().SetAbsorbDamage(absorbedDamage);
return(true);
}
