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