/// <summary> /// Decrease the Durability of the active weapon of a player /// </summary> /// <param name="pc">Player</param> /// <param name="amount">Amount of durability to lose</param> public static void WeaponLoseDura(ActorPC pc, ushort amount) { ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; SagaDB.Items.Weapon weapon = SagaDB.Items.WeaponFactory.GetActiveWeapon(pc); weapon.durability -= amount; eh.C.UpdateWeaponInfo(SagaMap.Packets.Server.WeaponAdjust.Function.Durability, weapon.durability); }
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 void LoseDura(ActorPC pc, SagaDB.Items.EQUIP_SLOT slot) { Packets.Server.ItemAdjust p = new SagaMap.Packets.Server.ItemAdjust(); ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e; if (pc.inv.EquipList.ContainsKey(slot)) { if (pc.inv.EquipList[slot].durability > 0) { pc.inv.EquipList[slot].durability--; p.SetContainer(1); p.SetFunction(SagaMap.Packets.Server.ItemAdjust.Function.Durability); p.SetSlot((byte)slot); p.SetValue(pc.inv.EquipList[slot].durability); eh.C.netIO.SendPacket(p, eh.C.SessionID); if (pc.inv.EquipList[slot].durability == 0) { pc.inv.EquipList[slot].active = 0; p = new SagaMap.Packets.Server.ItemAdjust(); p.SetContainer(1); p.SetSlot((byte)slot); p.SetFunction(SagaMap.Packets.Server.ItemAdjust.Function.Active); p.SetValue(0); eh.C.netIO.SendPacket(p, eh.C.SessionID); Bonus.BonusHandler.Instance.EquiqItem(pc, pc.inv.EquipList[slot], true); SkillHandler.CalcHPSP(ref pc); eh.C.SendCharStatus(0); eh.C.SendExtStats(); eh.C.SendBattleStatus(); MapServer.charDB.UpdateItem(pc, pc.inv.EquipList[slot]); } } } }
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) { 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); } } }
/// <summary> /// Remove a status icon of a actor /// </summary> /// <param name="actor">Actor</param> /// <param name="skillid">Icon to be removed</param> public static void RemoveStatusIcon(Actor actor, uint skillid) { if (actor.BattleStatus.Status == null) { actor.BattleStatus.Status = new List <uint>(); } if (!actor.BattleStatus.Status.Contains(skillid)) { return; } actor.BattleStatus.Status.Remove(skillid); Map map; if (actor.mapID == 0) { if (actor.type == ActorType.PC) { ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)actor.e; actor.mapID = (byte)eh.C.map.ID; } } if (!MapManager.Instance.GetMap(actor.mapID, out map)) { return; } List <Map.StatusArgs.StatusInfo> SList = new List <Map.StatusArgs.StatusInfo>(); SList.Add(new Map.StatusArgs.StatusInfo(skillid, 0)); Map.StatusArgs args = new Map.StatusArgs(Map.StatusArgs.EventType.Remove, SList); map.SendEventToAllActorsWhoCanSeeActor(Map.EVENT_TYPE.CHANGE_STATUS, args, actor, true); }
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 }
/// <summary> /// Delete a skill from Special skill list /// </summary> /// <param name="pc">Player</param> /// <param name="skillid">Skill to be removed</param> public static void SendDeleteSpecial(ActorPC pc, uint skillid) { ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; Packets.Server.RemoveSpecialSkill p1 = new SagaMap.Packets.Server.RemoveSpecialSkill(); p1.SetSkill(skillid); eh.C.netIO.SendPacket(p1, eh.C.SessionID); }
public static void Callback(Actor client) { try { Tasks.PassiveSkillStatus ss; ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)client.e; ss = (PassiveSkillStatus)client.Tasks["VenomCoat"]; if (ss.dueTime > 0) { if (client.type == ActorType.PC) { eh.C.SendBattleStatus(); } ss.dueTime--; } else { SkillHandler.RemoveStatusIcon(client, (uint)(1457400 + ss.level)); client.BattleStatus.atkskill -= CalcDamage(ss.level); eh.C.SendBattleStatus(); ss.Deactivate(); client.Tasks.Remove("VenomCoat"); ss = null; } } catch (Exception) { } }
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; } }
public override void OnDie() { base.OnDie(); if (delay != -1) { respawnTask.Activate(); } corpsetask.Activate(); ai.Pause(); if (this.map.GetActor(this.timeSignature.actorID) != null) { ActorPC pc = (ActorPC)this.map.GetActor(this.timeSignature.actorID); ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e; Packet p = new Packet();//don't know its name,maybe for some animation. p.data = new byte[9]; p.ID = 0x060E; p.PutUInt(this.Actor.id, 4); p.PutByte(4, 8); eh.C.netIO.SendPacket(p, eh.C.SessionID); SagaDB.Quest.Quest quest = Quest.QuestsManager.GetActiveQuest(pc); if (quest != null) //Add a temporary loot for a specificial quest { if (Quest.QuestsManager.MobQuestItem.ContainsKey(this.Actor.npcType)) { foreach (Quest.QuestsManager.LootInfo i in Quest.QuestsManager.MobQuestItem[this.Actor.npcType]) { if (i.QID == quest.ID) { if (quest.Steps.ContainsKey(i.SID)) { if (quest.Steps[i.SID].Status == 1) { if (this.Actor.NPCinv == null) { Actor.NPCinv = new List <Item>(); } int j = Global.Random.Next(0, 9999); if (j < i.rate) { this.Actor.NPCinv.Add(new Item(i.itemID)); } return; } } } } } } /*if (eh.C.QuestMobItem != null) * { * if (eh.C.QuestMobItem.ContainsKey(this.Actor.npcType)) * { * if (this.Actor.NPCinv == null) Actor.NPCinv = new List<Item>(); * this.Actor.NPCinv.Add(ItemFactory.GetItem((int)eh.C.QuestMobItem[this.Actor.npcType])); * } * }*/ } }
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; } } }
/// <summary> /// Add a skill to Skill List /// </summary> /// <param name="pc">Player</param> /// <param name="skillid">Skill to be added</param> /// <param name="slot">Slot</param> public static void SendAddSkill(ActorPC pc, uint skillid, byte slot) { ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; Packets.Server.SkillAdd p1 = new SagaMap.Packets.Server.SkillAdd(); p1.SetSkill(skillid); p1.SetSlot(slot); eh.C.netIO.SendPacket(p1, eh.C.SessionID); }
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) { 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 SendNavPoint(ActorPC pc) { ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e; Packets.Server.SendNavPoint p = new SagaMap.Packets.Server.SendNavPoint(); SagaDB.Quest.Quest quest = GetActiveQuest(pc); if (quest == null) { return; } if (!WayPoints.ContainsKey(quest.ID)) { return; } Dictionary <uint, List <WayPointInfo> > list1 = WayPoints[quest.ID]; uint sid = 0; foreach (uint i in quest.Steps.Keys) { if (quest.Steps[i].Status == 1) { sid = i; } if (sid != 0) { break; } } if (sid == 0) { return; } if (!list1.ContainsKey(sid)) { return; } List <WayPointInfo> list2 = list1[sid]; List <WayPointInfo> list3 = new List <WayPointInfo>(); foreach (WayPointInfo j in list2) { if (j.mapID == pc.mapID) { list3.Add(j); } } if (list3.Count == 0) { return; } p.SetQuestID(quest.ID); p.SetPosition(list3); eh.C.netIO.SendPacket(p, eh.C.SessionID); }
/// <summary> /// Check if the player has enough sp to cast skill, and decrease SP by the required amount /// </summary> /// <param name="pc">Player</param> /// <param name="skillid">Skill ID</param> /// <returns></returns> public static bool CheckSkillSP(ActorPC pc, SkillIDs skillid) { ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; Skill skill = SkillFactory.GetSkill((uint)skillid); if (pc.SP < skill.sp) { return(false); } pc.SP -= (ushort)skill.sp; eh.C.SendCharStatus(0); return(true); }
/// <summary> /// Increase Players LP /// </summary> /// <param name="pc">Player</param> /// <param name="skillID">ID of the skill that caused the increasement of LP</param> /// <param name="point">Amount</param> public static void GainLP(ActorPC pc, SkillIDs skillID, byte point) { ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; pc.LP += point; if (pc.LP > 5) { pc.LP = 5; } else { eh.C.SendSkillEffect(SkillFactory.GetSkill((uint)skillID).addition, SkillEffects.LP, point); } eh.C.SendCharStatus(0); }
/// <summary> /// Add EXP to a skill of a player /// </summary> /// <param name="pc">Player</param> /// <param name="skillid">Skill ID</param> /// <param name="exp">Maximum of exp to add</param> public static void AddSkillEXP(ref ActorPC pc, uint skillid, uint exp) { if (pc.BattleSkills.ContainsKey(skillid)) { SkillInfo info = pc.BattleSkills[skillid]; info.exp += (uint)Global.Random.Next(0, (int)exp); if (info.exp > SkillFactory.GetSkill(skillid).maxsxp) { info.exp = (uint)SkillFactory.GetSkill(skillid).maxsxp; } MapServer.charDB.UpdateSkill(pc, SkillType.Battle, info); ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; eh.C.UpdateSkillEXP(skillid, info.exp); } }
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args) { byte level; ActorPC pc = (ActorPC)sActor; level = (byte)(args.skillID - baseID + 1); ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; if (!SkillHandler.CheckSkillSP(pc, args.skillID)) { SkillHandler.SetSkillFailed(ref args); return; } SkillHandler.GainLP(pc, args.skillID, (byte)((level + 1) / 2)); args.damage = 0; args.isCritical = Map.SkillArgs.AttackResult.Nodamage; }
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)pc.e; byte level = (byte)(args.skillID - baseID + 1); if (!SkillHandler.CheckSkillSP(pc, args.skillID)) { SkillHandler.SetSkillFailed(ref args); return; } args.damage = 0; args.isCritical = Map.SkillArgs.AttackResult.Nodamage; Tasks.PassiveSkillStatus ss; switch (SkillHandler.AddPassiveStatus(dActor, "WeaponBlessing", 255, out ss, new SagaMap.Tasks.PassiveSkillStatus.CallBackFunc(Callback), new SagaMap.Tasks.PassiveSkillStatus.DeactivateFunc(Deactivate))) { case PassiveStatusAddResult.Updated: ss.dueTime = 900000; ss.period = 900000; SkillHandler.RemoveStatusIcon(dActor, (uint)(baseID + ss.level - 1)); if (ss.Activated()) { ss.Deactivate(); } ss.Activate(); BonusHandler.Instance.SkillAddAddition(dActor, (uint)args.skillID, false); ss.level = level; SkillHandler.AddStatusIcon(dActor, (uint)args.skillID, 900000); break; case PassiveStatusAddResult.OK: ss.dueTime = 900000; ss.period = 900000; ss.level = level; ss.Activate(); BonusHandler.Instance.SkillAddAddition(dActor, (uint)args.skillID, false); SkillHandler.AddStatusIcon(dActor, (uint)args.skillID, 900000); break; } if (dActor.type == ActorType.PC) { eh = (SagaMap.ActorEventHandlers.PC_EventHandler)dActor.e; eh.C.SendBattleStatus(); } } }
public static void Proc(ref Actor sActor, ref Actor dActor, ref Map.SkillArgs args) { 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) { args.damage = CalcDamage(sActor, dActor, args); if (sActor.type == ActorType.PC) { ActorPC targetPC = (ActorPC)sActor; ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)targetPC.e; try { switch (args.skillID) { case SkillIDs.NormanShortSwordAttack: SkillHandler.AddPassiveSkillEXP(targetPC, "ShortSwordMastery", 1406900, 3); break; case SkillIDs.NormanLongSwordAttack: SkillHandler.AddPassiveSkillEXP(targetPC, "LongSwordMastery", 1416900, 3); SkillHandler.AddPassiveSkillEXP(targetPC, "ArtOfWarrior", 1419100, 3); break; case SkillIDs.NormanDampflintAttack: SkillHandler.AddPassiveSkillEXP(targetPC, "DampRifleMastery", 1426900, 3); SkillHandler.AddPassiveSkillEXP(targetPC, "FirePractice", 1429100, 3); break; case SkillIDs.NormanDampflintAttack2: SkillHandler.AddPassiveSkillEXP(targetPC, "DampRifleMastery", 1426900, 3); SkillHandler.AddPassiveSkillEXP(targetPC, "CloseOrderDrill", 1427100, 3); break; case SkillIDs.NormanSwordStickAttack: case SkillIDs.NormanSwordStickAttack2: SkillHandler.AddPassiveSkillEXP(targetPC, "ShortSwordMastery", 1406900, 3); break; } } catch (Exception) { } SkillHandler.WeaponLoseDura(targetPC, 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) { if (sActor.type == ActorType.PC) { ActorPC pc = (ActorPC)sActor; ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e; byte level = (byte)(args.skillID - baseID + 1); if (!SkillHandler.CheckSkillSP(pc, 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, "Tracking", 900000, Addition.AdditionType.Buff)); } }
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) || pc.LP < 3) { SkillHandler.SetSkillFailed(ref args); return; } pc.LP -= 3; args.damage = 0; args.isCritical = Map.SkillArgs.AttackResult.Nodamage;// This skill is not for attacking SkillHandler.ApplyAddition(dActor, new Additions.Global.DefaultBuff(args.skillID, dActor, "ShieldBlock", 300000, Addition.AdditionType.Buff)); } }
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)pc.e; byte level = (byte)(args.skillID - baseID + 1); if (!SkillHandler.CheckSkillSP(pc, args.skillID)) { SkillHandler.SetSkillFailed(ref args); return; } SkillHandler.GainLP(pc, args.skillID); args.damage = 0; args.isCritical = Map.SkillArgs.AttackResult.Nodamage; SkillHandler.ApplyAddition(dActor, new Additions.Recruit.Designation(args.skillID, dActor)); } }
private static void Deactivate(Actor client) { try { Tasks.PassiveSkillStatus ss = (Tasks.PassiveSkillStatus)client.Tasks["WeaponBlessing"]; SkillHandler.RemoveStatusIcon(client, (uint)(baseID + ss.level - 1)); BonusHandler.Instance.SkillAddAddition(client, (uint)(baseID + ss.level - 1), true); if (client.type == ActorType.PC) { ActorPC pc = (ActorPC)client; ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e; eh.C.SendBattleStatus(); } } catch (Exception ex) { Logger.ShowError(ex); } }
public static void SetQuestStepStatus(ActorPC pc, uint id, uint step, byte status) { SagaDB.Quest.QuestType type; if (id == 0 || step == 0) { return; } SagaDB.Quest.Quest quest; if (pc.QuestTable.ContainsKey(id)) { quest = pc.QuestTable[id]; type = SagaDB.Quest.QuestType.OfficialQuest; } else { if (pc.PersonalQuestTable.ContainsKey(id)) { quest = pc.PersonalQuestTable[id]; type = SagaDB.Quest.QuestType.PersonalQuest; } else { return; } } if (quest.Steps.ContainsKey(step) == false) { return; } SagaDB.Quest.Step step2 = quest.Steps[step]; step2.Status = status; if (status == 2 && step2.nextStep != 0) { quest.Steps[step2.nextStep].Status = 1; } MapServer.charDB.UpdateQuest(pc, type, quest); Packets.Server.UpdateQuest p = new SagaMap.Packets.Server.UpdateQuest(); p.SetQuestID(id); p.SetStep(step2); ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e; eh.C.netIO.SendPacket(p, eh.C.SessionID); }
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; } 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) { args.damage = CalcDamage(sActor, dActor, args); } } SkillHandler.PhysicalAttack(ref sActor, ref dActor, args.damage, SkillHandler.AttackElements.NATRAL, ref args); }
/// <summary> /// Send all status icons of a Actor to player /// </summary> /// <param name="pc">Player</param> /// <param name="actor">Actor</param> public static void SendAllStatusIcons(ActorPC pc, Actor actor) { ActorEventHandlers.PC_EventHandler eh = (ActorEventHandlers.PC_EventHandler)pc.e; if (actor.BattleStatus == null) { actor.BattleStatus = new BattleStatus(); } if (actor.BattleStatus.Status == null) { actor.BattleStatus.Status = new List <uint>(); } List <Map.StatusArgs.StatusInfo> SList = new List <Map.StatusArgs.StatusInfo>(); foreach (uint i in actor.BattleStatus.Status) { SList.Add(new Map.StatusArgs.StatusInfo(i, 0)); } Map.StatusArgs args = new Map.StatusArgs(Map.StatusArgs.EventType.Add, SList); if (SList.Count != 0) { eh.OnChangeStatus(actor, args); } }