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