/// <summary>
/// Starts a new session and calls Gift.
/// </summary>
/// <param name="target"></param>
/// <param name="creature"></param>
/// <param name="gift"></param>
public void StartGift(NPC target, Creature creature, Item gift)
{
if (!this.Start(target, creature))
return;
this.Script.GiftAsync(gift);
}
/// <summary>
/// Checks if target's Mana Shield is active, calculates mana
/// damage, and sets target action's Mana Damage property if applicable.
/// </summary>
/// <param name="target"></param>
/// <param name="damage"></param>
/// <param name="tAction"></param>
public static void Handle(Creature target, ref float damage, TargetAction tAction)
{
// Mana Shield active?
if (!target.Conditions.Has(ConditionsA.ManaShield))
return;
// Get Mana Shield skill to get the rank's vars
var manaShield = target.Skills.Get(SkillId.ManaShield);
if (manaShield == null) // Checks for things that should never ever happen, yay.
return;
// Var 1 = Efficiency
var manaDamage = damage / manaShield.RankData.Var1;
if (target.Mana >= manaDamage)
{
// Damage is 0 if target's mana is enough to cover it
damage = 0;
}
else
{
// Set mana damage to target's mana and reduce the remaining
// damage from life if the mana is not enough.
damage -= (manaDamage - target.Mana) * manaShield.RankData.Var1;
manaDamage = target.Mana;
}
// Reduce mana
target.Mana -= manaDamage;
if (target.Mana <= 0)
ChannelServer.Instance.SkillManager.GetHandler<StartStopSkillHandler>(SkillId.ManaShield).Stop(target, manaShield);
tAction.ManaDamage = manaDamage;
}
public bool Prepare(Creature creature, Skill skill, Packet packet)
{
Send.SkillFlashEffect(creature);
Send.SkillPrepare(creature, skill.Info.Id, skill.GetCastTime());
return true;
}
/// <summary>
/// Sends BurnItemR to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="success"></param>
public static void BurnItemR(Creature creature, bool success)
{
var packet = new Packet(Op.BurnItemR, creature.EntityId);
packet.PutByte(success);
creature.Client.Send(packet);
}
/// <summary>
/// Starts a new session and calls Talk.
/// </summary>
/// <param name="target"></param>
/// <param name="creature"></param>
public void StartTalk(NPC target, Creature creature)
{
if (!this.Start(target, creature))
return;
this.Script.TalkAsync();
}
/// <summary>
/// Handles healing training.
/// </summary>
/// <param name="creature"></param>
/// <param name="target"></param>
/// <param name="skill"></param>
private void OnPlayerHealsCreature(Creature creature, Creature target, Skill healingSkill)
{
var skill = creature.Skills.Get(SkillId.MagicMastery);
if (skill == null)
return;
if (healingSkill.Info.Id == SkillId.Healing)
{
var index = 0;
if (skill.Info.Rank >= SkillRank.RF && skill.Info.Rank <= SkillRank.RD)
index = 1;
else if (skill.Info.Rank >= SkillRank.RC && skill.Info.Rank <= SkillRank.R6)
index = 3;
if (index != 0)
{
skill.Train(index); // Use Healing magic on an injured person.
if (target.Life < 0)
skill.Train(index + 1); // Use Healing magic on a critically injured person.
}
}
else if (healingSkill.Info.Id == SkillId.PartyHealing && !creature.IsGiant)
{
if (skill.Info.Rank >= SkillRank.R5 && skill.Info.Rank <= SkillRank.R1)
skill.Train(7); // Use Party Healing.
}
}
/// <summary>
/// Sends Disappear to creature's client.
/// </summary>
/// <remarks>
/// Should this be broadcasted? What does it even do? TODO.
/// </remarks>
/// <param name="creature"></param>
public static void Disappear(Creature creature)
{
var packet = new Packet(Op.Disappear, MabiId.Channel);
packet.PutLong(creature.EntityId);
creature.Client.Send(packet);
}
/// <summary>
/// Sends MailsRequestR to creature's client.
/// </summary>
/// <param name="creature"></param>
public static void MailsRequestR(Creature creature)
{
var packet = new Packet(Op.MailsRequestR, creature.EntityId);
// ...
creature.Client.Send(packet);
}
/// <summary>
/// Reduces damage by target's magic defense and protection.
/// </summary>
/// <param name="target"></param>
/// <param name="damage"></param>
/// <param name="defense"></param>
/// <param name="protection"></param>
public static void HandleMagicDefenseProtection(Creature target, ref float damage, bool defense = true, bool protection = true)
{
if (defense)
damage = Math.Max(1, damage - target.MagicDefense);
if (protection && damage > 1)
damage = Math.Max(1, damage - (damage / 100 * target.MagicProtection));
}
/// <summary>
/// Bolt specific use code.
/// </summary>
/// <param name="attacker"></param>
/// <param name="skill"></param>
/// <param name="target"></param>
protected override void UseSkillOnTarget(Creature attacker, Skill skill, Creature mainTarget)
{
// Create actions
var aAction = new AttackerAction(CombatActionType.RangeHit, attacker, skill.Info.Id, mainTarget.EntityId);
aAction.Set(AttackerOptions.Result);
var cap = new CombatActionPack(attacker, skill.Info.Id, aAction);
var targets = new List<Creature>();
targets.Add(mainTarget);
targets.AddRange(mainTarget.Region.GetCreaturesInRange(mainTarget.GetPosition(), SplashRange).Where(a => a != mainTarget && attacker.CanTarget(a) && attacker.CanAttack(a)));
// Damage
var damage = this.GetDamage(attacker, skill);
var max = Math.Min(targets.Count, skill.Stacks);
for (int i = 0; i < max; ++i)
{
var target = targets[i];
var targetDamage = damage;
target.StopMove();
var tAction = new TargetAction(CombatActionType.TakeHit, target, attacker, skill.Info.Id);
tAction.Set(TargetOptions.Result);
tAction.Stun = TargetStun;
// Full damage for the first target, -10% for every subsequent one.
targetDamage -= (targetDamage * 0.1f) * i;
// Reduce damage
var maxDamage = damage; //Damage without Defense and Protection
// Reduce damage
Defense.Handle(aAction, tAction);
SkillHelper.HandleMagicDefenseProtection(target, ref targetDamage);
ManaShield.Handle(target, ref targetDamage, tAction, maxDamage, true);
// Deal damage
if (targetDamage > 0)
target.TakeDamage(tAction.Damage = targetDamage, attacker);
if (target == mainTarget)
target.Aggro(attacker);
// Death/Knockback
this.HandleKnockBack(attacker, target, tAction);
cap.Add(tAction);
}
// Override stun set by defense
aAction.Stun = AttackerStun;
Send.Effect(attacker, Effect.UseMagic, EffectSkillName);
Send.SkillUseStun(attacker, skill.Info.Id, aAction.Stun, 1);
this.BeforeHandlingPack(attacker, skill);
cap.Handle();
}
/// <summary>
/// Sends QuestClear to creature's client.
/// </summary>
/// <remarks>
/// Removes quest from quest log.
/// </remarks>
/// <param name="creature"></param>
/// <param name="questId"></param>
public static void QuestClear(Creature creature, long questId)
{
var packet = new Packet(Op.QuestClear, creature.EntityId);
packet.PutLong(questId);
creature.Client.Send(packet);
}
/// <summary>
/// Sends PetUnregister to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="pet"></param>
public static void PetUnregister(Creature creature, Creature pet)
{
var packet = new Packet(Op.PetUnregister, creature.EntityId);
packet.PutLong(pet.EntityId);
creature.Client.Send(packet);
}
/// <summary>
/// Sends TelePetR to pet's client.
/// </summary>
/// <param name="pet"></param>
/// <param name="success"></param>
public static void TelePetR(Creature pet, bool success)
{
var packet = new Packet(Op.TelePetR, pet.EntityId);
packet.PutByte(success);
pet.Client.Send(packet);
}
/// <summary>
/// Completes skill, dropping a cobweb.
/// </summary>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="packet"></param>
public void Complete(Creature creature, Skill skill, Packet packet)
{
var cobweb = new Item(ItemId);
cobweb.Drop(creature.Region, creature.GetPosition(), 200, creature, true);
Send.SkillComplete(creature, skill.Info.Id);
}
/// <summary>
/// Prepares skill, goes straight to use to skip readying and using it.
/// </summary>
/// <remarks>
/// The client will take a moment to send the Complete packet,
/// as if it would cast the skill first.
/// </remarks>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="packet"></param>
public bool Prepare(Creature creature, Skill skill, Packet packet)
{
Send.SkillUse(creature, skill.Info.Id, 0);
skill.State = SkillState.Used;
return true;
}
/// <summary>
/// Sends TouchPropR to creature's client.
/// </summary>
/// <param name="creature"></param>
public static void TouchPropR(Creature creature)
{
var packet = new Packet(Op.TouchPropR, creature.EntityId);
packet.PutByte(true);
creature.Client.Send(packet);
}
/// <summary>
/// Readies the skill.
/// </summary>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="packet"></param>
/// <returns></returns>
public bool Ready(Creature creature, Skill skill, Packet packet)
{
Send.UseMotion(creature, 10, 0);
Send.SkillReady(creature, skill.Info.Id);
return true;
}
/// <summary>
/// Reduces weapon's durability and increases its proficiency.
/// Only updates weapon type items that are not null.
/// </summary>
/// <param name="attacker">Creature who's weapon is updated.</param>
/// <param name="target">
/// The target of the skill, used for power rating calculations.
/// If target is null, prof will be rewarded regardless of target.
/// </param>
/// <param name="weapons">Weapons to update.</param>
public static void UpdateWeapon(Creature attacker, Creature target, ProficiencyGainType profGainType, params Item[] weapons)
{
if (attacker == null)
return;
var rnd = RandomProvider.Get();
// Add prof if no target was specified or the target is not "Weakest".
var addProf = (target == null || attacker.GetPowerRating(target) >= PowerRating.Weak);
foreach (var weapon in weapons.Where(a => a != null && a.IsTrainableWeapon))
{
// Durability
var reduce = rnd.Next(1, 30);
attacker.Inventory.ReduceDurability(weapon, reduce);
// Don't add prof if weapon is broken.
if (weapon.Durability == 0)
addProf = false;
// Proficiency
if (addProf)
{
var amount = Item.GetProficiencyGain(attacker.Age, profGainType);
attacker.Inventory.AddProficiency(weapon, amount);
}
}
}
/// <summary>
/// Sends SosButtonRequestR to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="enabled"></param>
public static void SosButtonRequestR(Creature creature, bool enabled)
{
var packet = new Packet(Op.SosButtonRequestR, creature.EntityId);
packet.PutByte(enabled);
creature.Client.Send(packet);
}
/// <summary>
/// Sends NewQuest to creature's client.
/// </summary>
/// <param name="character"></param>
/// <param name="quest"></param>
public static void NewQuest(Creature character, Quest quest)
{
var packet = new Packet(Op.NewQuest, character.EntityId);
packet.AddQuest(quest);
character.Client.Send(packet);
}
protected void EnsureAuth(Creature invoker, bool isSelfCommand)
{
if (!HasAuth(invoker, isSelfCommand))
{
throw new Exception(string.Format(Localization.Get("You're not authorized to use '{0}'."), Name));
}
}
/// <summary>
/// Sends PartySetQuestR to creature's client.
/// </summary>
/// <param name="party"></param>
/// <param name="success"></param>
public static void PartySetQuestR(Creature creature, bool success)
{
var packet = new Packet(Op.PartySetQuestR, creature.EntityId);
packet.PutByte(success);
creature.Client.Send(packet);
}
/// <summary>
/// New Skill.
/// </summary>
/// <param name="creature"></param>
/// <param name="id"></param>
/// <param name="rank"></param>
/// <param name="race"></param>
public Skill(Creature creature, SkillId id, SkillRank rank, int race)
{
_creature = creature;
_race = race;
this.Info.Id = id;
this.Info.Rank = rank;
this.Info.MaxRank = rank;
this.Info.Flag = SkillFlags.Shown;
// The conditions are set to the max and are reduced afterwards,
// making them "Complete" once they reach 0. Initializing to 1
// in case of problems.
this.Info.ConditionCount1 = 1;
this.Info.ConditionCount2 = 1;
this.Info.ConditionCount3 = 1;
this.Info.ConditionCount4 = 1;
this.Info.ConditionCount5 = 1;
this.Info.ConditionCount6 = 1;
this.Info.ConditionCount7 = 1;
this.Info.ConditionCount8 = 1;
this.Info.ConditionCount9 = 1;
this.LoadRankData();
}
/// <summary>
/// Sends RequestRebirthR to creature's client.
/// </summary>
/// <param name="vehicle"></param>
public static void RequestRebirthR(Creature creature, bool success)
{
var packet = new Packet(Op.RequestRebirthR, MabiId.Login);
packet.PutByte(success);
creature.Client.Send(packet);
}
/// <summary>
/// Sends EnterRebirthR to creature's client.
/// </summary>
/// <param name="creature"></param>
public static void EnterRebirthR(Creature creature)
{
var packet = new Packet(Op.EnterRebirthR, creature.EntityId);
packet.PutByte(0);
creature.Client.Send(packet);
}
/// <summary>
/// Prepares skill, skips right to used.
/// </summary>
/// <remarks>
/// Doesn't check anything, like what you can gather with what,
/// because at this point there's no chance for abuse.
/// </remarks>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="packet"></param>
/// <returns></returns>
public bool Prepare(Creature creature, Skill skill, Packet packet)
{
var entityId = packet.GetLong();
var collectId = packet.GetInt();
// You shall stop
creature.StopMove();
var creaturePosition = creature.GetPosition();
// Get target (either prop or creature)
var targetEntity = this.GetTargetEntity(creature.Region, entityId);
if (targetEntity != null)
creature.Temp.GatheringTargetPosition = targetEntity.GetPosition();
// Check distance
if (!creaturePosition.InRange(creature.Temp.GatheringTargetPosition, MaxDistance))
{
Send.Notice(creature, Localization.Get("Your arms are too short to reach that from here."));
return false;
}
// ? (sets creatures position on the client side)
Send.CollectAnimation(creature, entityId, collectId, creaturePosition);
// Use
Send.SkillUse(creature, skill.Info.Id, entityId, collectId);
skill.State = SkillState.Used;
return true;
}
/// <summary>
/// Sends DestroyExpiredItemsR to creature's client.
/// </summary>
/// <param name="creature"></param>
/// <param name="success"></param>
public static void DestroyExpiredItemsR(Creature creature, bool success)
{
var packet = new Packet(Op.DestroyExpiredItemsR, creature.EntityId);
packet.PutByte(success);
creature.Client.Send(packet);
}
/// <summary>
/// Readies the skill.
/// </summary>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="packet"></param>
/// <returns></returns>
public override bool Ready(Creature creature, Skill skill, Packet packet)
{
Send.Effect(creature, 5, (byte)0);
Send.SkillReady(creature, skill.Info.Id);
return true;
}
/// <summary>
/// Stops meditation.
/// </summary>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="dict"></param>
/// <returns></returns>
public override StartStopResult Stop(Creature creature, Skill skill, MabiDictionary dict)
{
creature.Regens.Remove("Meditation");
creature.Conditions.Deactivate(ConditionsE.Meditation);
return StartStopResult.Okay;
}
/// <summary>
/// Starts the skill.
/// </summary>
/// <param name="creature"></param>
/// <param name="skill"></param>
/// <param name="dict"></param>
/// <returns></returns>
public override StartStopResult Start(Creature creature, Skill skill, MabiDictionary dict)
{
creature.Conditions.Activate(ConditionsA.ManaShield);
Send.Effect(creature, Effect.ManaShield);
return StartStopResult.Okay;
}
