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); }