public static void ENCHANTER_CALLLIGHTING(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[0, 3] += 70 + 30 * arguments.SkillLevel;
matrix[1, 3] += 150 + (60 + (10 * arguments.SkillLevel));
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
/// <remarks>
/// Last time edited: 10-01-2008
///
/// This script is invoked when player x uses his/hers
/// promise stone. Basicly it's used to warp fast to your
/// save location and warp back.
///
/// Dungeon -> Village -> Dungeon: goes to dungeon lvl 1
/// Village -> Village -> Village: stays on the current village
/// Map -> Village -> Map: goes to the latest map restore point
/// </remarks>
public static void GENERAL_PROMISESTONE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Character current = arguments.Sender as Character;
Zone zone = current.currentzone;
uint requiredzeny = (uint)((current.Level - 4) * 10);
if (requiredzeny > current.ZENY)
{
Common.Errors.GeneralErrorMessage(current, (uint)Generalerror.NotEnoughMoney);
}
WorldCoordinate lpos = current.lastlocation.map > 0 ? current.lastlocation : current.savelocation;
WorldCoordinate spos = current.savelocation;
if (current.currentzone.Type == ZoneType.Village)
{
arguments.Failed = !CommonFunctions.Warp(current, lpos.map);
}
else
{
arguments.Failed = !CommonFunctions.Warp(current, spos.map);
}
if (arguments.Failed == false)
{
current.ZENY -= (uint)((current.Level - 4) * 10);
CommonFunctions.UpdateZeny(current);
}
}
}
public override void OnSkillUsedByTarget(MapObject source, SkillBaseEventArgs e)
{
bool isdamage = e.Result == Saga.SkillBaseEventArgs.ResultType.Block || e.Result == Saga.SkillBaseEventArgs.ResultType.Critical || e.Result == Saga.SkillBaseEventArgs.ResultType.Normal;
if (e.Damage > 0)
{
bool HasDied = (isdamage && e.Damage >= this.HP && this.stance != 7);
if (HasDied)
{
this.HP = 0;
e.Target.OnDie(e.Sender);
e.Sender.OnEnemyDie(e.Target);
lock (this)
{
this.stance = 7;
Common.Actions.UpdateStance(this);
Console.WriteLine("Target dead");
}
}
else
{
this.HP -= (ushort)e.Damage;
}
}
base.OnSkillUsedByTarget(source, e);
}
public static void SWORDMAN_MAGNUMBREAK(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = (uint)(45 + (5 * arguments.SkillLevel));
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void SWORDMAN_LONGSWORD(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void ENCHANTER_FIREBOLT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[1, 3] = (int)(matrix[1, 3] * 0.1 + ((double)0.03 * (double)arguments.SkillLevel));
matrix[1, 3] += 100 + (50 * arguments.SkillLevel);
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_DAMPFLINT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.DoLpIncrease(asource);
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void NOVICE_MARTIALARTS(SkillBaseEventArgs bargument)
{
SkillToggleEventArgs arguments = (SkillToggleEventArgs)bargument;
Actor starget = arguments.Target as Actor;
Common.Skills.CreateAddition(starget, arguments.Addition);
}
public static void RECRUIT_ROTATINGFIRESHOT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[1, 3] += 100 + (50 * arguments.SkillLevel);
matrix[4, 3] += (Lvldiff * 120);
asource.Status.CurrentLp -= 1;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
/// <remarks>
/// Last time edited: 10-01-2008
///
/// This script is invoked when player x uses his/hers
/// promise stone. Basicly it's used to warp fast to your
/// save location and warp back.
///
/// Dungeon -> Village -> Dungeon: goes to dungeon lvl 1
/// Village -> Village -> Village: stays on the current village
/// Map -> Village -> Map: goes to the latest map restore point
/// </remarks>
public static void GENERAL_PROMISESTONE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Character current = arguments.Sender as Character;
Zone zone = current.currentzone;
uint requiredzeny = (uint)((current.Level - 4) * 10);
if (requiredzeny > current.ZENY)
{
Common.Errors.GeneralErrorMessage(current, (uint)Generalerror.NotEnoughMoney);
}
WorldCoordinate lpos = current.lastlocation.map > 0 ? current.lastlocation : current.savelocation;
WorldCoordinate spos = current.savelocation;
if (current.currentzone.Type == ZoneType.Village)
{
arguments.Failed = !CommonFunctions.Warp(current, lpos.map);
}
else
{
arguments.Failed = !CommonFunctions.Warp(current, spos.map);
}
if (arguments.Failed == false)
{
current.ZENY -= (uint)((current.Level - 4) * 10);
CommonFunctions.UpdateZeny(current);
}
}
}
public static void RECRUIT_LURINGSHOT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
arguments.UpdateCancelAddition(1004901, 5000, 0, atarget);
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = 0;
arguments.Result = SkillBaseEventArgs.ResultType.NoDamage;
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void NOVICE_QUICKBLOW(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[1, 2] = (int)((double)(matrix[1, 2]) * (double)(0.7 + 0.05 * arguments.SkillLevel));
matrix[2, 3] = (int)((double)(matrix[2, 3]) * (double)(1.3 + 0.05 * arguments.SkillLevel));
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.DoLpIncrease(asource);
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
private static void BaseMagicalAttack(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetMagicalSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
matrix[0, 1] = 0; matrix[1, 1] = 0;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_PIERCINGSHOT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
//Increase both Maximum and minimum attack of yourself and removes the armor
matrix.matrix[0, 0] += matrix[3, 0];
matrix.matrix[1, 0] += matrix[3, 0];
matrix.matrix[3, 0] = 0;
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_DISARM(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_AIMINGSHOT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[2, 3] = 1200 + (int)((double)matrix[2, 3] * (double)((double)0.5 - ((double)0.05 * (double)arguments.SkillLevel)));
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void SWORDMAN_COURAGEOUSASSAULT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
switch (asource.Status.CurrentLp)
{
case 1:
arguments.Damage += (uint)(7 + arguments.SkillLevel);
break;
case 2:
arguments.Damage += (uint)(13 + arguments.SkillLevel * 2);
break;
case 3:
arguments.Damage += (uint)(21 + arguments.SkillLevel * 3);
break;
case 4:
arguments.Damage += (uint)(29 + arguments.SkillLevel * 4);
break;
case 5:
arguments.Damage += (uint)(37 + arguments.SkillLevel * 5);
break;
}
asource.Status.CurrentLp = 0;
asource.Status.Updates |= 1;
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void SWORDMAN_COURAGEOUSASSAULT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
switch (asource.Status.CurrentLp)
{
case 1:
arguments.Damage += (uint)(7 + arguments.SkillLevel);
break;
case 2:
arguments.Damage += (uint)(13 + arguments.SkillLevel * 2);
break;
case 3:
arguments.Damage += (uint)(21 + arguments.SkillLevel * 3);
break;
case 4:
arguments.Damage += (uint)(29 + arguments.SkillLevel * 4);
break;
case 5:
arguments.Damage += (uint)(37 + arguments.SkillLevel * 5);
break;
}
asource.Status.CurrentLp = 0;
asource.Status.Updates |= 1;
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_POLLEOSHOT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
switch (asource.Status.CurrentLp)
{
case 1:
matrix.matrix[1, 2] += (9 + 1 * arguments.SkillLevel);
break;
case 2:
matrix.matrix[1, 2] += (19 + 2 * arguments.SkillLevel);
break;
case 3:
matrix.matrix[1, 2] += (30 + 3 * arguments.SkillLevel);
break;
case 4:
matrix.matrix[1, 2] += (42 + 4 * arguments.SkillLevel);
break;
case 5:
matrix.matrix[1, 2] += (55 + 5 * arguments.SkillLevel);
break;
}
asource.Status.CurrentLp = 0;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_POLLEOSHOT(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
switch (asource.Status.CurrentLp)
{
case 1:
matrix.matrix[1, 2] += (9 + 1 * arguments.SkillLevel);
break;
case 2:
matrix.matrix[1, 2] += (19 + 2 * arguments.SkillLevel);
break;
case 3:
matrix.matrix[1, 2] += (30 + 3 * arguments.SkillLevel);
break;
case 4:
matrix.matrix[1, 2] += (42 + 4 * arguments.SkillLevel);
break;
case 5:
matrix.matrix[1, 2] += (55 + 5 * arguments.SkillLevel);
break;
}
asource.Status.CurrentLp = 0;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void GENERAL_ITEMQUESTSTART(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.ItemUsage)
{
ItemSkillUsageEventArgs arguments = (ItemSkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Item;
arguments.Damage = 0;
Console.WriteLine("Start using quest: {0}", arguments.ItemInfo.quest);
}
}
public static void GENERAL_ITEMQUESTSTART(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.ItemUsage)
{
ItemSkillUsageEventArgs arguments = (ItemSkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Item;
arguments.Damage = 0;
Console.WriteLine("Start using quest: {0}", arguments.ItemInfo.quest);
}
}
public static void RECRUIT_PREDATORFOCUS(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
Common.Skills.UpdateAddition(arguments.Target as Actor, arguments.Addition, 900000);
}
}
public static void RECRUIT_PREDATORFOCUS(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
Common.Skills.UpdateAddition(arguments.Target as Actor, arguments.Addition, 900000);
}
}
public static void ENCHANTER_MEDITATION(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(arguments.Target as Actor, arguments.Addition);
}
}
public static void RECRUIT_TRACKING(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(bargument.Target as Actor, arguments.Addition, 900000);
}
}
public static void RECRUIT_TRACKING(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(bargument.Target as Actor, arguments.Addition, 900000);
}
}
public static void SWORDMAN_SHIELDBLOCK(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(arguments.Target as Actor, arguments.Addition, 300000);
}
}
public static void RECRUIT_BAYONETSTANCE(SkillBaseEventArgs bargument)
{
Console.WriteLine("Bayonet stance");
if (bargument.Context == Saga.Enumarations.SkillContext.SkillToggle)
{
bargument.Failed = false;
SkillToggleEventArgs arguments = (SkillToggleEventArgs)bargument;
Actor starget = arguments.Target as Actor;
arguments.Toggle(starget, arguments.SpellInfo.addition);
}
}
public static void ENCHANTER_MENTALTRAINING(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(bargument.Sender as Actor, arguments.Addition, 600000);
}
}
public static void GENERAL_SWEETCOCTAIL(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.ItemUsage)
{
ItemSkillUsageEventArgs arguments = (ItemSkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Item;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.CreateAddition(arguments.Sender as Actor, arguments.Addition, 90000);
}
}
public static void GENERAL_THREEMINUTESRICECAKE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.ItemUsage)
{
ItemSkillUsageEventArgs arguments = (ItemSkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Item;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.CreateAddition(arguments.Sender as Actor, arguments.Addition, 240000);
}
}
public static void SWORDMAN_SHIELDBLOCK(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(arguments.Target as Actor, arguments.Addition, 300000);
}
}
public static void GENERAL_POTION(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.ItemUsage)
{
ItemSkillUsageEventArgs arguments = (ItemSkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Item;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.DoAddition(arguments.Sender as Actor, arguments.Sender, arguments.Addition);
}
}
public static void GENERAL_ADVENTURERPOTION(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.ItemUsage)
{
ItemSkillUsageEventArgs arguments = (ItemSkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Item;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.DoAddition(arguments.Sender as Actor, arguments.Sender, arguments.Addition);
}
}
public static void ENCHANTER_WEAPONBLESSING(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(arguments.Target as Actor, arguments.Addition, 600000);
}
}
public static void ENCHANTER_SWORDSTICKSTANCE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillToggle)
{
SkillToggleEventArgs arguments = (SkillToggleEventArgs)bargument;
Actor starget = arguments.Target as Actor;
if (Common.Skills.HasAddition(starget, arguments.Addition))
Common.Skills.DeleteStaticAddition(starget, arguments.Addition);
else
Common.Skills.CreateAddition(starget, arguments.Addition);
}
}
public static void GENERAL_EMOTICON(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.CanCheckEquipmentDurabillity = false;
arguments.CanCheckWeaponDurabillity = false;
arguments.Failed = false;
}
}
public static void GENERAL_EMOTICON(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.CanCheckEquipmentDurabillity = false;
arguments.CanCheckWeaponDurabillity = false;
arguments.Failed = false;
}
}
public static void THIEF_SHADOWSTEP(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(bargument.Sender as Actor, arguments.Addition, 300000);
//Do lp effect
Common.Skills.DoAddition(bargument.Sender as Actor, bargument.Target as Actor, 1003301);
}
}
public static void NOVICE_TENSION(SkillBaseEventArgs bargument)
{
Actor asource = bargument.Sender as Actor;
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
}
}
public static void CLOWN_FRESHAIR(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Common.Skills.UpdateAddition(bargument.Target as Actor, arguments.Addition, 600000);
//Do lp effect
Common.Skills.DoAddition(bargument.Sender as Actor, bargument.Target as Actor, 1003301);
}
}
public static void ENCHANTER_HEAL(SkillBaseEventArgs bargument)
{
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, atarget);
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Heal;
arguments.Damage = 0;
arguments.Failed = false;
Singleton.Additions.DeapplyAddition(arguments.Addition, atarget);
}
}
public static void NOVICE_TENSION(SkillBaseEventArgs bargument)
{
Actor asource = bargument.Sender as Actor;
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
}
}
public static void ENCHANTER_HEAL(SkillBaseEventArgs bargument)
{
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, atarget);
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Heal;
arguments.Damage = 0;
arguments.Failed = false;
Singleton.Additions.DeapplyAddition(arguments.Addition, atarget);
}
}
public static void CLOWN_SUPPORTIVESTANCE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillToggle)
{
SkillToggleEventArgs arguments = (SkillToggleEventArgs)bargument;
Actor starget = arguments.Target as Actor;
if (Common.Skills.HasAddition(starget, arguments.Addition))
{
Common.Skills.DeleteStaticAddition(starget, arguments.Addition);
}
else
{
Common.Skills.CreateAddition(starget, arguments.Addition);
}
}
}
public static void NOVICE_ACTDEAD(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillToggle)
{
SkillToggleEventArgs arguments = (SkillToggleEventArgs)bargument;
Actor starget = arguments.Target as Actor;
if (Common.Skills.HasAddition(starget, arguments.Addition))
{
Common.Skills.DeleteStaticAddition(starget, arguments.Addition);
}
else
{
Common.Skills.CreateAddition(starget, arguments.Addition, 30000);
}
}
}
public static void GENERAL_OPENBOX(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
if (arguments.Target is OpenBox)
{
OpenBox current = arguments.Target as OpenBox;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
current.OnOpenBox(arguments.Sender as Character);
}
}
}
public static void GENERAL_OPENBOX(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
if (arguments.Target is OpenBox)
{
OpenBox current = arguments.Target as OpenBox;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
arguments.Failed = false;
current.OnOpenBox(arguments.Sender as Character);
}
}
}
public static void THIEF_DISGUISE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Actor starget = arguments.Sender as Actor;
if (starget is Actor)
{
Common.Skills.UpdateAddition(starget, arguments.Addition, 240000);
}
else
{
arguments.Failed = true;
}
}
}
public static void CLOWN_SELFHEAL(SkillBaseEventArgs bargument)
{
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Heal;
arguments.Damage = 0;
arguments.Failed = false;
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
//Do lp effect
Common.Skills.DoAddition(bargument.Sender as Actor, bargument.Target as Actor, 1003301);
}
}
public static void THIEF_DISGUISE(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Actor starget = arguments.Sender as Actor;
if (starget is Actor)
{
Common.Skills.UpdateAddition(starget, arguments.Addition, 240000);
}
else
{
arguments.Failed = true;
}
}
}
/// <summary>
/// Occurs when reducing the LP for reduction
/// </summary>
/// <returns>True if LP is reduced</returns>
//public bool OnLPReduction()
//{
// if(LASTLP_TICK<_status.LASTLP_ADD)
// LASTLP_TICK=_status.LASTLP_ADD;
// int delta_t = Environment.TickCount - LASTLP_TICK;
// if (delta_t > 60000)
// {
// LASTLP_TICK = Environment.TickCount;
// if (_status.CurrentLp > 0)
// {
// _status.CurrentLp--;
// this._status.Updates |= 1;
// return true;
// }
// }
// return false;
//}
public override void OnSkillUsedByTarget(MapObject source, SkillBaseEventArgs e)
{
//If durabillity could be checked
if (e.CanCheckEquipmentDurabillity)
{
Common.Durabillity.DoEquipment(this.Target as Character, e.Damage);
}
//Set sword drawn
if (e.SpellInfo.hate > 0)
{
this.ISONBATTLE = true;
}
//Use base skill
base.OnSkillUsedByTarget(source, e);
}
public static void GENERAL_CORNUTUSMAGIC(SkillBaseEventArgs bargument)
{
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
arguments.Result = Saga.SkillBaseEventArgs.ResultType.NoDamage;
arguments.Damage = 0;
if (arguments.Target.ModelId == 10021 || arguments.Target.ModelId == 10022)
{
arguments.Failed = !Common.Items.GiveItem(arguments.Sender as Character, 0, 0);
}
else
{
arguments.Failed = true;
}
}
}
public static void CLOWN_SELFHEAL(SkillBaseEventArgs bargument)
{
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
arguments.Result = Saga.SkillBaseEventArgs.ResultType.Heal;
arguments.Damage = 0;
arguments.Failed = false;
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
//Do lp effect
Common.Skills.DoAddition(bargument.Sender as Actor, bargument.Target as Actor, 1003301);
}
}
public static void RECRUIT_FINALBLOW(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
//Apply additions and deapply after
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
//Calculation
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
//Remove all LP
asource.Status.CurrentLp = 0;
asource.Status.Updates |= 1;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
if (arguments.Damage >= atarget.Status.CurrentHp)
{
asource.Status.CurrentLp = 7;
}
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
public static void RECRUIT_FINALBLOW(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
//Apply additions and deapply after
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
Singleton.Additions.ApplyAddition(arguments.Addition, asource);
matrix = arguments.GetDefaultSkillMatrix(asource, atarget);
Singleton.Additions.DeapplyAddition(arguments.Addition, asource);
//Calculation
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
//Remove all LP
asource.Status.CurrentLp = 0;
asource.Status.Updates |= 1;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
if (arguments.Damage >= atarget.Status.CurrentHp)
asource.Status.CurrentLp = 7;
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
private static void BaseRangedAttack(SkillBaseEventArgs bargument)
{
int Lvldiff;
SkillUsageEventArgs.SkillMatrix matrix;
Actor asource = bargument.Sender as Actor;
Actor atarget = bargument.Target as Actor;
if (asource != null && atarget != null && bargument.Context == Saga.Enumarations.SkillContext.SkillUse)
{
SkillUsageEventArgs arguments = (SkillUsageEventArgs)bargument;
matrix = arguments.GetRangedSkillMatrix(asource, atarget);
Lvldiff = arguments.GetCappedLevelDifference(matrix);
matrix[4, 3] += (Lvldiff * 120);
matrix[0, 1] = 0; matrix[1, 1] = 0;
if (arguments.IsMissed(matrix) || arguments.IsBlocked(matrix))
{
return;
}
else
{
arguments.CanCheckEquipmentDurabillity = true;
arguments.CanCheckWeaponDurabillity = true;
arguments.Damage = arguments.GetDamage(matrix);
arguments.Damage = arguments.GetDefenseReduction(matrix, arguments.Damage);
arguments.IsCritical(matrix);
}
}
else
{
bargument.Failed = true;
}
}
/// <summary>
/// Occurs when reducing the LP for reduction
/// </summary>
/// <returns>True if LP is reduced</returns>
//public bool OnLPReduction()
//{
// if(LASTLP_TICK<_status.LASTLP_ADD)
// LASTLP_TICK=_status.LASTLP_ADD;
// int delta_t = Environment.TickCount - LASTLP_TICK;
// if (delta_t > 60000)
// {
// LASTLP_TICK = Environment.TickCount;
// if (_status.CurrentLp > 0)
// {
// _status.CurrentLp--;
// this._status.Updates |= 1;
// return true;
// }
// }
// return false;
//}
public override void OnSkillUsedByTarget(MapObject source, SkillBaseEventArgs e)
{
//If durabillity could be checked
if (e.CanCheckEquipmentDurabillity)
Common.Durabillity.DoEquipment(this.Target as Character, e.Damage);
//Set sword drawn
if (e.SpellInfo.hate > 0)
this.ISONBATTLE = true;
//Use base skill
base.OnSkillUsedByTarget(source, e);
}
protected virtual void Default(SkillBaseEventArgs arguments)
{
}
