public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (NotEnemyCheck(source, skill, info))
{
return(false);
}
var sourceBonuses = source.Bonuses();
var targetObject = source.Target().targetObject;
var targetBonuses = targetObject.Bonuses();
sourceBonuses.RemoveAnyPositiveBuff();
targetBonuses.RemoveAnyPositiveBuff();
float critDamagePc = skill.GetFloatInput("crit_dmg_pc");
float critChancePc = skill.GetFloatInput("crit_chance_pc");
float time = skill.GetFloatInput("time");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
}
Buff critDamageBuff = new Buff(skill.id, null, Common.BonusType.increase_crit_damage_on_pc, time, critDamagePc);
Buff critChanceBuff = new Buff(skill.id, null, Common.BonusType.increase_crit_chance_on_cnt, time, critChancePc);
sourceBonuses.SetBuff(critDamageBuff, source);
sourceBonuses.SetBuff(critChanceBuff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(Common.SkillUseState.normal);
float time = skill.GetFloatInput("time");
float hpPc = skill.GetFloatInput("hp_pc");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
hpPc *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
//source.Skills().Set41C(time, hpPc);
source.Bonuses().SetBuff(new Buff(skill.idInt.ToString(), null, Common.BonusType.buff_41c, time, hpPc), source);
return(true);
}
//private static readonly ILogger log = LogManager.GetCurrentClassLogger();
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
info.SetSkillUseState(SkillUseState.normal);
float pc = skill.GetFloatInput("hpdmg_pc");
float time = skill.GetFloatInput("time");
var bonuses = source.Bonuses();
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
pc *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
Buff damageBuff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_damage_on_pc, time, pc);
Buff healingBuff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_healing_on_pc, time, pc);
//log.InfoFormat("set damage and healing buff {0}:{1} green", pc, time);
bonuses.SetBuff(damageBuff, source);
bonuses.SetBuff(healingBuff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
var damagable = source.Damagable();
float hpPc = skill.GetFloatInput("hp_pc");
float hpTime = skill.GetFloatInput("hp_time");
float hpBuffPc = skill.GetFloatInput("hpbuff_pc");
float hpBuffTime = skill.GetFloatInput("hpbuff_time");
float hpForSec = damagable.maximumHealth * hpPc / hpTime;
string id = source.Id + skill.data.Id.ToString();
bool mastery = RollMastery(source);
if (mastery)
{
hpForSec *= 2;
hpBuffTime *= 2;
}
damagable.SetRestoreHPPerSec(hpForSec, hpTime, id);
Buff buff = new Buff(skill.id, null, Common.BonusType.increase_healing_speed_on_pc, hpBuffTime, hpBuffPc);
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 time = skill.GetFloatInput("time");
float dmgPc = skill.GetFloatInput("dmg_pc");
float healPc = skill.GetFloatInput("heal_pc");
bool mastery = RollMastery(source);
if (mastery)
{
time *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
//DamagableObject targetDamagable = source.GetComponent<PlayerTarget>().targetObject.GetComponent<DamagableObject>();
//source.GetComponent<PlayerSkills>().AddDamageHealReceiver(new PlayerSkills.DamageReceiver { damagePercent = dmgPc, expireTime = Time.curtime() + time, target = targetDamagable });
Buff hbuff = new Buff(skill.id + "_heal", null, BonusType.increase_healing_speed_on_pc, time, healPc);
Buff dbuff = new Buff(skill.id + "_dmg", null, BonusType.increase_damage_on_pc, time, dmgPc);
source.Bonuses().SetBuff(hbuff, source);
source.Bonuses().SetBuff(dbuff, source);
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);
}
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();
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();
float radius = skill.GetFloatInput("radius");
float dmgPc = skill.GetFloatInput("dmg_pc");
float dmgTime = skill.GetFloatInput("dmg_time");
float dronPc = skill.GetFloatInput("dron_pc");
float dronTime = skill.GetFloatInput("dron_time");
bool mastery = RollMastery(source);
if (mastery)
{
dmgPc *= 2;
dronTime *= 2;
}
ActionOnEnemyTargets((item) => {
Buff buff = new Buff(skill.id, null, Common.BonusType.decrease_damage_on_pc, dmgTime, dmgPc);
item.Bonuses().SetBuff(buff, source);
}, source, source, radius);
Buff dronBuff = new Buff(skill.id, null, Common.BonusType.increase_dron_strength_on_pc, dronTime, dronPc);
source.Bonuses().SetBuff(dronBuff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
var damagable = source.Damagable();
float hpPc = skill.GetFloatInput("hp_pc");
float hpPcTimed = skill.GetFloatInput("hp_pc_timed");
float hpTime = skill.GetFloatInput("hp_time");
bool mastery = RollMastery(source);
if (mastery)
{
hpPc *= 2;
hpTime *= 2;
}
float restoreInstance = damagable.maximumHealth * hpPc;
damagable.RestoreHealth(source, restoreInstance);
float hpPerSec = damagable.maximumHealth * hpPcTimed / hpTime;
string id = source.Id + skill.data.Id.ToString();
damagable.SetRestoreHPPerSec(hpPerSec, hpTime, id);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
float hpRestorePc = skill.GetFloatInput("hp_restore_pc");
float maxHpPc = skill.GetFloatInput("max_hp_pc");
bool mastery = RollMastery(source);
if (mastery)
{
maxHpPc *= 2;
hpRestorePc *= 2;
}
var damagable = source.Damagable();
float restoredHp = hpRestorePc * damagable.baseMaximumHealth;
damagable.RestoreHealth(source, restoredHp);
var skills = source.Skills();
Buff buff = new Buff(skill.data.Id.ToString(), source, Common.BonusType.increase_max_hp_on_pc, -1, maxHpPc, () => {
return(true);
}, skill.data.Id);
source.Bonuses().SetBuff(buff, source);
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 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(SkillUseState.normal);
if (!source)
{
return(false);
}
float cooldownPc = skill.GetFloatInput("cooldown_pc");
float cooldownTime = skill.GetFloatInput("cooldown_time");
float radius = skill.GetFloatInput("radius");
var sourceChar = source.GetComponent <CharacterObject>();
//var items = (source.world as MmoWorld).GetItems((it) => {
// if(!source) {
// return false;
// }
// if(!it) {
// return false;
// }
// if (it.GetComponent<PlayerBonuses>() && it.GetComponent<CharacterObject>()) {
// if (source.transform.DistanceTo(it.transform) <= radius) {
// if (sourceChar.RelationTo(it.GetComponent<CharacterObject>()) == FractionRelation.Enemy) {
// return true;
// }
// }
// }
// return false;
//});
var enemies = GetEnemiesAndNeutrals(source, radius);
bool mastery = RollMastery(source);
if (mastery)
{
cooldownTime *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
foreach (var p in enemies)
{
Buff buff = new Buff(skill.idInt.ToString(), null, BonusType.increase_cooldown_on_pc, cooldownTime, cooldownPc);
//Buff buff = new Buff(skill.data.Id.ToString(), null, BonusType.increase_cooldown_on_cnt, cooldownTime, cooldownCnt);
p.Value.GetComponent <PlayerBonuses>().SetBuff(buff, source);
}
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 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);
bool castOnTarget = true;
if (source.Target().hasTarget)
{
if (FriendTargetInvalid(source))
{
info.SetSkillUseState(Common.SkillUseState.invalidTarget);
castOnTarget = false;
}
else
{
if (NotCheckDistance(source))
{
info.SetSkillUseState(Common.SkillUseState.tooFar);
castOnTarget = false;
}
}
}
else
{
castOnTarget = false;
}
float hpPc = skill.GetFloatInput("hp_pc");
float hpTime = skill.GetFloatInput("hp_time");
bool mastery = RollMastery(source);
if (mastery)
{
hpTime *= 2;
hpPc *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
//source.Skills().Set415(hpTime, hpPc);
if (castOnTarget)
{
source.Target().targetObject.Bonuses().SetBuff(new Buff(skill.data.Id.ToString() + source.Id, null, Common.BonusType.increase_healing_speed_on_pc, hpTime, hpPc), source);
}
else
{
source.Bonuses().SetBuff(new Buff(skill.data.Id.ToString() + source.Id, null, Common.BonusType.increase_healing_speed_on_pc, hpTime, hpPc), source);
}
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 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();
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(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();
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();
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();
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);
float radius = skill.GetFloatInput("radius");
bool mastery = RollMastery(source);
if (mastery)
{
radius *= 2;
info.SetMastery(true);
}
else
{
info.SetMastery(false);
}
var targets = GetTargets(source, source, radius);
foreach (var pTarget in targets)
{
var item = pTarget.Value;
if (item.invisible)
{
item.SetInvisibility(false);
}
}
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
float hpPc = skill.GetFloatInput("hp_pc");
float hpTime = skill.GetFloatInput("hp_time");
bool mastery = RollMastery(source);
if (mastery)
{
hpTime *= 2;
}
source.Skills().Set432(hpTime, hpPc);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
if (ShotToEnemyRestricted(source, skill))
{
return(false);
}
float radius = skill.GetFloatInput("radius");
var targetObject = source.Target().targetObject;
var buffInfoCollection = targetObject.Bonuses().GetAllDebuffInfo();
var items = GetHealTargets(targetObject, targetObject, radius);
float buffMult = 1;
bool mastery = RollMastery(source);
if (mastery)
{
buffMult *= 2;
}
foreach (var pItem in items)
{
var itemBonuses = pItem.Value.Bonuses();
foreach (var buffInfo in buffInfoCollection)
{
itemBonuses.SetBuff(new Buff(Guid.NewGuid().ToString(), null, buffInfo.bonusType, buffInfo.time * buffMult, buffInfo.value), source);
}
}
return(true);
}
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();
float resistPc = skill.GetFloatInput("resist_pc");
float resistTime = skill.GetFloatInput("resist_time");
bool mastery = RollMastery(source);
if (mastery)
{
resistTime *= 2;
}
Buff buff = new Buff(skill.data.Id.ToString(), null, Common.BonusType.increase_resist_on_pc, resistTime, resistPc);
source.Bonuses().SetBuff(buff, source);
return(true);
}
public override bool TryCast(NebulaObject source, PlayerSkill skill, out Hashtable info)
{
info = new Hashtable();
hpPc = skill.GetFloatInput("hp_pc");
dmgMult = skill.GetFloatInput("dmg_mult");
bool mastery = RollMastery(source);
if (mastery)
{
hpPc *= 2;
dmgMult *= 2;
}
return(true);
}
