public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
byte level;
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e;
Tasks.PassiveSkillStatus ss;
level = (byte)(args.skillID - baseID + 1);
switch (SkillHandler.AddPassiveStatus(pc, "MentalTraining", 3, out ss, new PassiveSkillStatus.DeactivateFunc(Deactivate)))
{
case PassiveStatusAddResult.WeaponMissMatch:
if (ss != null)
{
BonusHandler.Instance.SkillAddAddition(pc, (uint)(baseID + ss.level - 1), true);
}
break;
case PassiveStatusAddResult.Updated:
BonusHandler.Instance.SkillAddAddition(pc, (uint)(baseID + ss.level - 1), true);
BonusHandler.Instance.SkillAddAddition(pc, (uint)args.skillID, false);
ss.level = level;
break;
case PassiveStatusAddResult.OK:
ss.level = level;
BonusHandler.Instance.SkillAddAddition(pc, (uint)args.skillID, false);
break;
}
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
byte level = (byte)(args.skillID - baseID + 1);
ActorPC pc = (ActorPC)sActor;
int dmg = 0;
switch (pc.LP)
{
case 1:
dmg = 7 + level;
break;
case 2:
dmg = 13 + level * 2;
break;
case 3:
dmg = 21 + level * 3;
break;
case 4:
dmg = 29 + level * 4;
break;
case 5:
dmg = 37 + level * 5;
break;
}
return((uint)(sActor.BattleStatus.atk + dmg));
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
byte level = (byte)(args.skillID - baseID + 1);
return((uint)(150 * level));
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
byte level = (byte)(args.skillID - baseID + 1);
int dmg = 0;
switch (pc.LP)
{
case 1:
dmg = 10 + level * 10;
break;
case 2:
dmg = 25 + level * 15;
break;
case 3:
dmg = 40 + level * 20;
break;
case 4:
dmg = 55 + level * 25;
break;
case 5:
dmg = 70 + level * 30;
break;
}
return((uint)(pc.BattleStatus.atk + dmg));
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e;
if (sActor.type == ActorType.PC)
{
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Heal;
ActorPC targetPC;
args.damage = CalcDamage(sActor, dActor, args);
if (dActor.type == ActorType.PC)
{
targetPC = (ActorPC)dActor;
eh = (SagaMap.ActorEventHandlers.PC_EventHandler)targetPC.e;
targetPC.HP += (ushort)args.damage;
eh.C.SendSkillEffect(SkillFactory.GetSkill((uint)args.skillID).addition, SkillEffects.HP, args.damage);
if (targetPC.HP > targetPC.maxHP)
{
targetPC.HP = targetPC.maxHP;
}
eh.C.SendCharStatus(0);
}
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e;
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
Mob mob = (Mob)dActor.e;
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;// This skill is not for attacking
if (!mob.Hate.ContainsKey(pc.id))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
SkillHandler.AddSkillEXP(ref pc, (uint)args.skillID, 3);
ushort value = GetHateReduction(args);
if (mob.Hate[pc.id] > value)
{
mob.Hate[pc.id] -= (byte)value;
}
else
{
mob.Hate[pc.id] = 0;
}
}
//TODO:
//20% Sadness status on enemy
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
ActorPC pc = (ActorPC)sActor;
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
args.damage = 0;
args.isCritical = SkillHandler.CalcCrit(sActor, dActor, args, SkillHandler.AttackType.Physical);
if (args.isCritical != Map.SkillArgs.AttackResult.Miss && args.isCritical != Map.SkillArgs.AttackResult.Block)
{
if (dActor.type == ActorType.NPC)
{
ActorNPC npc = (ActorNPC)dActor;
if (npc.npcType >= 10000 && npc.npcType < 50000)
{
Mob mob = (Mob)npc.e;
if (mob.Hate.ContainsKey(sActor.id))
{
mob.Hate[sActor.id] = 65535;
}
else
{
mob.Hate.Add(sActor.id, 65535);
}
}
}
}
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e;
if (sActor.type == ActorType.PC)
{
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
}
else//currently cannot be cast on player
{
SkillHandler.SetSkillFailed(ref args);
return;
}
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage; // This skill is not for attacking
if (!pc.BattleStatus.Additions.ContainsKey("BayonetStance"))
{
SkillHandler.ApplyAddition(pc, new Additions.Global.DefaultStance(args.skillID, pc, "BayonetStance"));
args.failed = true;
}
else
{
args.failed = false;
SkillHandler.RemoveAddition(pc, pc.BattleStatus.Additions["BayonetStance"]);
}
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
byte level = (byte)(args.skillID - baseID + 1);
return((uint)(pc.BattleStatus.atk + 25 + level * 25));
}
/// <summary>
/// Damage calculation for skills not defined in skill table
/// </summary>
/// <param name="sActor"></param>
/// <param name="dActor"></param>
/// <param name="args"></param>
/// <returns></returns>
public static uint CalcDamage(ref Actor sActor, ref Actor dActor, Map.SkillArgs args)
{
ActorPC targetPC;
switch (args.skillID)
{
case SkillIDs.RedPotion:
targetPC = (ActorPC)sActor;
PCPotionHeal(ref targetPC, 20, 25, 0, 0, 10, 1500, args);
return(0);
case SkillIDs.RedPotion2:
targetPC = (ActorPC)sActor;
PCPotionHeal(ref targetPC, 30, 40, 0, 0, 10, 1500, args);
return(0);
case SkillIDs.RedPotion3:
targetPC = (ActorPC)sActor;
PCPotionHeal(ref targetPC, 50, 70, 0, 0, 10, 1500, args);
return(0);
default:
if (dActor.type != ActorType.NPC)
{
return(10);
}
return((uint)Global.Random.Next(1, 10));
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
byte level;
ActorPC pc = (ActorPC)sActor;
Tasks.PassiveSkillStatus ss;
args.damage = 0;
args.isCritical = 0;
level = (byte)(args.skillID - baseID + 1);
switch (SkillHandler.AddPassiveStatus(pc, "SwordStickMastery", 3, out ss, new PassiveSkillStatus.DeactivateFunc(Deactivate)))
{
case PassiveStatusAddResult.WeaponMissMatch:
if (ss != null)
{
BonusHandler.Instance.SkillAddAddition(pc, (uint)(baseID + ss.level - 1), true);
}
break;
case PassiveStatusAddResult.Updated:
BonusHandler.Instance.SkillAddAddition(pc, (uint)(baseID + ss.level - 1), true);
BonusHandler.Instance.SkillAddAddition(pc, (uint)args.skillID, false);
ss.level = level;
break;
case PassiveStatusAddResult.OK:
ss.level = level;
BonusHandler.Instance.SkillAddAddition(pc, (uint)args.skillID, false);
break;
}
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
int damage;
damage = sActor.BattleStatus.atk + SkillHandler.GetSkillAtkBonus(args.skillID);
return((uint)damage);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
byte level;
ActorPC pc = (ActorPC)sActor;
Tasks.PassiveSkillStatus ss;
Tasks.Regeneration rege = (Tasks.Regeneration)pc.Tasks["RegenerationSP"];
args.damage = 0;
args.isCritical = 0;
level = (byte)(args.skillID - baseID + 1);
if (!pc.BattleSkills.ContainsKey((uint)args.skillID))
{
if (pc.Tasks.ContainsKey("ChakraaBreath"))
{
ss = (PassiveSkillStatus)pc.Tasks["ChakraaBreath"];
rege.sp -= (ushort)GetLevelValue(level);
pc.Tasks.Remove("ChakraaBreath");
}
return; //if current weapon is not Short Sword
}
if (pc.Tasks.ContainsKey("ChakraaBreath"))
{
ss = (PassiveSkillStatus)pc.Tasks["ChakraaBreath"];
rege.sp -= (ushort)GetLevelValue(ss.level);
ss.level = level;
rege.sp += (ushort)GetLevelValue(level);
}
else
{
ss = new PassiveSkillStatus(level);
rege.sp += (ushort)GetLevelValue(level);
pc.Tasks.Add("ChakraaBreath", ss);
}
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
int damage;
damage = sActor.BattleStatus.atk;
return((uint)damage);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
ActorPC pc = (ActorPC)sActor;
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
SkillHandler.GainLP(pc, args.skillID);
}
args.damage = 0;
args.isCritical = SkillHandler.CalcCrit(sActor, dActor, args, SkillHandler.AttackType.Physical);
if (args.isCritical != Map.SkillArgs.AttackResult.Miss && args.isCritical != Map.SkillArgs.AttackResult.Block)
{
ActorPC targetPC = (ActorPC)sActor;
args.damage = CalcDamage(sActor, dActor, args);
}
if (args.damage <= 0)
{
args.damage = 1;
}
SkillHandler.PhysicalAttack(ref sActor, ref dActor, args.damage, SkillHandler.AttackElements.NEUTRAL, ref args);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e;
if (sActor.type == ActorType.PC)
{
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;// This skill is not for attacking
byte level = (byte)(args.skillID - baseID + 1);
SkillHandler.AddSkillEXP(ref pc, (uint)args.skillID, 3);
if (!pc.Tasks.ContainsKey("ActDead"))
{
Tasks.PassiveSkillStatus t = new SagaMap.Tasks.PassiveSkillStatus(level);
args.failed = true;
pc.Tasks.Add("ActDead", t);
SkillHandler.AddStatusIcon(pc, (uint)args.skillID, 0);
}
else
{
args.failed = false;
pc.Tasks.Remove("ActDead");
SkillHandler.RemoveStatusIcon(pc, (uint)args.skillID);
}
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
ActorPC pc = (ActorPC)sActor;
if (!SkillHandler.CheckSkillSP(pc, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
SkillHandler.GainLP(pc, args.skillID);
args.damage = 0;
args.isCritical = SkillHandler.CalcCrit(sActor, dActor, args, SkillHandler.AttackType.Magical);
if (args.isCritical != Map.SkillArgs.AttackResult.Miss && args.isCritical != Map.SkillArgs.AttackResult.Block)
{
uint MDamage;
uint WindDamage;
args.damage = CalcDamage(sActor, dActor, args);
MDamage = SkillHandler.MagicalAttack(ref sActor, ref dActor, args.damage, SkillHandler.AttackElements.NEUTRAL, ref args);
args.damage = CalcWindDamage(sActor, dActor, args);
WindDamage = SkillHandler.MagicalAttack(ref sActor, ref dActor, args.damage, SkillHandler.AttackElements.WIND, ref args);
args.damage = MDamage + WindDamage;
}
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)sActor.e;
if (!SkillHandler.CheckSkillSP(pc, args.skillID) || pc.LP < 1)
{
SkillHandler.SetSkillFailed(ref args);
return;
}
pc.LP -= 1;
eh.C.SendCharStatus(0);
Map map;
if (dActor.mapID == 0)
{
if (dActor.type == ActorType.PC)
{
eh = (SagaMap.ActorEventHandlers.PC_EventHandler)dActor.e;
dActor.mapID = (byte)eh.C.map.ID;
}
}
if (MapManager.Instance.GetMap(dActor.mapID, out map))
{
foreach (Actor actor in map.GetActorsArea(dActor, 500, true))
{
Actor tmp = actor;
if (actor == sActor || actor.stance == Global.STANCE.DIE || actor.type != ActorType.NPC)
{
continue;
}
args.damage = 0;
args.isCritical = SkillHandler.CalcCrit(sActor, actor, args, SkillHandler.AttackType.Physical);
ActorNPC npc = (ActorNPC)actor;
if (npc.npcType < 10000)
{
continue;
}
if (args.isCritical != Map.SkillArgs.AttackResult.Miss && args.isCritical != Map.SkillArgs.AttackResult.Block)
{
ActorPC targetPC = (ActorPC)sActor;
args.damage = CalcDamage(sActor, actor, args);
}
SkillHandler.PhysicalAttack(ref sActor, ref tmp, args.damage, SkillHandler.AttackElements.NEUTRAL, ref args);
if (actor != dActor)
{
args.targetActorID = actor.id;
map.SendEventToAllActorsWhoCanSeeActor(Map.EVENT_TYPE.SKILL, args, sActor, true);
}
}
args.targetActorID = dActor.id;
}
else
{
SkillHandler.SetSkillFailed(ref args);
return;
}
}
}
private static uint CalcDamage(Actor sActor, Actor dActor, Map.SkillArgs args)
{
if (args.skillID == SkillIDs.NormanDampflintAttack)
{
return((uint)sActor.BattleStatus.ratk);
}
return((uint)sActor.BattleStatus.atk);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
args.damage = 0;
args.isCritical = 0;
bool ifActivate = (SagaDB.Items.WeaponFactory.GetActiveWeapon((ActorPC)sActor).type == 2);
SkillHandler.ApplyAddition(dActor, new Additions.Global.DefaultPassiveSkill(args.skillID, dActor, "ArtOfWarrior", ifActivate));
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
ActorPC pc = (ActorPC)sActor;
args.damage = 0;
args.isCritical = 0;
SkillHandler.ApplyAddition(dActor, new Additions.Global.DefaultPassiveSkill(args.skillID, dActor, "StrongMind", true));
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
ActorPC pc = (ActorPC)sActor;
if (pc.SP < SkillFactory.GetSkill((uint)args.skillID).sp)
{
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Miss;
args.failed = true;
return;
}
else
{
ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e;
pc.SP -= (ushort)SkillFactory.GetSkill((uint)args.skillID).sp;
pc.LP += 1;
if (pc.LP > 5)
{
pc.LP = 5;
}
eh.C.SendCharStatus(0);
}
}
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;
byte level = (byte)(args.skillID - baseID + 1);
ActorPC targetpc = (ActorPC)dActor;
Tasks.PassiveSkillStatus ss;
if (targetpc.Tasks.ContainsKey("VenomCoat"))
{
ss = (PassiveSkillStatus)targetpc.Tasks["VenomCoat"];
ss.level = level;
SkillHandler.RemoveStatusIcon(dActor, (uint)1457400 + ss.level);
targetpc.BattleStatus.atkskill -= CalcDamage(ss.level);
ss.Deactivate();
ss.dueTime = 1;
ss.period = 600000;
targetpc.BattleStatus.atkskill += CalcDamage(level);
SkillHandler.AddStatusIcon(dActor, (uint)args.skillID, 600000);
ss.Activate();
}
else
{
ss = new PassiveSkillStatus(level);
ss.dueTime = 1;
ss.period = 600000;
ss.client = dActor;
ss.Func = new PassiveSkillStatus.CallBackFunc(Callback);
targetpc.Tasks.Add("VenomCoat", ss);
targetpc.BattleStatus.atkskill += CalcDamage(level);
SkillHandler.AddStatusIcon(dActor, (uint)args.skillID, 600000);
ss.Activate();
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
ActorItem item = (ActorItem)dActor;
ActorPC pc = (ActorPC)sActor;
MapItem eh = (MapItem)item.e;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;
args.damage = 0;
eh.OnOpen(pc);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
byte level;
ActorPC pc = (ActorPC)sActor;
ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e;
Tasks.PassiveSkillStatus ss;
level = (byte)(args.skillID - baseID + 1);
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;
if (dActor.type == ActorType.PC)
{
ActorPC targetpc = (ActorPC)dActor;
if (targetpc.Tasks.ContainsKey("Meditation"))
{
ss = (PassiveSkillStatus)targetpc.Tasks["Meditation"];
targetpc.BattleStatus.fireresist -= CalcValue(ss.level);
targetpc.BattleStatus.iceresist -= CalcValue(ss.level);
targetpc.BattleStatus.windresist -= CalcValue(ss.level);
targetpc.BattleStatus.holyresist -= CalcValue(ss.level);
targetpc.BattleStatus.darkresist -= CalcValue(ss.level);
ss.level = level;
targetpc.BattleStatus.fireresist += CalcValue(level);
targetpc.BattleStatus.iceresist += CalcValue(level);
targetpc.BattleStatus.windresist += CalcValue(level);
targetpc.BattleStatus.holyresist += CalcValue(level);
targetpc.BattleStatus.darkresist += CalcValue(level);
if (dActor.type == ActorType.PC)
{
eh = (ActorEventHandlers.PC_EventHandler)dActor.e;
eh.C.SendBattleStatus();
}
}
else
{
ss = new PassiveSkillStatus(level);
ss.DeactFunc += Deactivate;
ss.client = dActor;
targetpc.Tasks.Add("Meditation", ss);
targetpc.BattleStatus.fireresist += CalcValue(level);
targetpc.BattleStatus.iceresist += CalcValue(level);
targetpc.BattleStatus.windresist += CalcValue(level);
targetpc.BattleStatus.holyresist += CalcValue(level);
targetpc.BattleStatus.darkresist += CalcValue(level);
if (dActor.type == ActorType.PC)
{
eh = (ActorEventHandlers.PC_EventHandler)dActor.e;
eh.C.SendBattleStatus();
}
}
}
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type != ActorType.PC)
{
SkillHandler.SetSkillFailed(ref args);
return;
}
ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)sActor.e;
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage; //not for damage
eh.C.OnUsePromiseStone(sActor.mapID, sActor.x, sActor.y, sActor.z);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
if (!SkillHandler.CheckSkillSP((ActorPC)dActor, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;
SkillHandler.ApplyAddition(dActor, new Additions.Global.DefaultBuff(args.skillID, dActor, "FatalContract", 240000, Addition.AdditionType.Buff));
}
}
public static uint PhysicalAttack(ref Actor sActor, ref Actor dActor, uint damage, AttackElements element, ref Map.SkillArgs args)
{
//Real damage calculation
if (element != AttackElements.NATRAL)
{
if (damage > (uint.MaxValue / 2))
{
damage = 0;
}
if (args.isCritical == Map.SkillArgs.AttackResult.Critical)
{
damage = damage * 2;
args.damage = damage;
}
float reduced;
if (dActor.BattleStatus.def < 1000)
{
reduced = ((float)(dActor.BattleStatus.def) / 1000) * damage;
damage -= (uint)reduced;
args.damage = damage;
}
else
{
damage = 0;
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Block;
}
}
//Shield Block: Damage reduction
if (sActor.BattleStatus.Additions.ContainsKey("ShieldBlock"))
{
damage = (uint)(damage * 0.7);
}
//Shiel Block: Attack reflection
if (dActor.BattleStatus.Additions.ContainsKey("ShieldBlock"))
{
Addition addition = dActor.BattleStatus.Additions["ShieldBlock"];
Map.SkillArgs newarg = new Map.SkillArgs(args.skillType, args.isCritical, (uint)SkillIDs.ShieldBlock, sActor.id, 0);
Map map;
newarg.damage = (uint)(damage * (0.07 + 0.03));
if (MapManager.Instance.GetMap(dActor.mapID, out map))
{
map.SendEventToAllActorsWhoCanSeeActor(Map.EVENT_TYPE.SKILL, newarg, dActor, true);
SkillAttack(ref dActor, ref sActor, newarg.damage, ref newarg);
}
}
SkillAttack(ref sActor, ref dActor, damage, ref args);
return(damage);
}
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args)
{
if (sActor.type == ActorType.PC)
{
if (!SkillHandler.CheckSkillSP((ActorPC)dActor, args.skillID))
{
SkillHandler.SetSkillFailed(ref args);
return;
}
args.damage = 0;
args.isCritical = Map.SkillArgs.AttackResult.Nodamage;
SkillHandler.ApplyAddition(dActor, new Additions.Thief.RapidRun(args.skillID, dActor));
}
}
public void OnActorChangesState(Actor aActor, MapEventArgs args)
{
//send actorChangeState
Packets.Server.ActorChangeState p1 = new SagaMap.Packets.Server.ActorChangeState();
p1.SetActorID(aActor.id);
p1.SetBattleState(aActor.state > 0);
p1.SetStance(aActor.stance);
if (args != null)
{
Map.SkillArgs arg = (Map.SkillArgs)args;
p1.SetTargetActor(arg.targetActorID);
}
C.netIO.SendPacket(p1, C.SessionID);
}
private void SendResult(ActorPC pc, Map.SkillArgs args)
{
SagaMap.ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e;
Packets.Server.ItemActive packet = new SagaMap.Packets.Server.ItemActive();
packet.SetSkillType(args.skillType);
packet.SetContainer(0);
packet.SetIndex(0);
packet.SetSkillID((uint)args.skillID);
packet.SetSActor(pc.id);
packet.SetDActor(pc.id);
packet.SetValue(args.damage);
eh.C.netIO.SendPacket(packet, eh.C.SessionID);
eh.C.SendCharStatus(0);
}
public static void CastPassivSkill(ref ActorPC pc)
{
SkillCommand command;
byte skilltype;
Actor target = (Actor)pc;
CalcBattleStatus(ref target);
foreach (uint id in pc.BattleSkills.Keys)
{
skilltype = SkillFactory.GetSkill(id).skilltype;
if (skilltype != 2) continue;
if (SkillCommands.ContainsKey((SkillIDs)id) == true)
{
Map.SkillArgs args = new Map.SkillArgs(skilltype, 0, id, 0, 0);
command = SkillCommands[(SkillIDs)id];
command.Invoke(ref target, ref target, ref args);
}
}
}
