public void TargetHit(NpcMonsterSkill npcMonsterSkill)
{
if (Npc == null ||
!((DateTime.Now - LastSkill).TotalMilliseconds >= 1000 + Npc.BasicCooldown * 250) &&
npcMonsterSkill == null ||
HasBuff(CardType.SpecialAttack, (byte)AdditionalTypes.SpecialAttack.NoAttack))
{
return;
}
LastSkill = DateTime.Now;
if (npcMonsterSkill != null)
{
if (CurrentMp < npcMonsterSkill.Skill.MpCost)
{
FollowTarget();
return;
}
npcMonsterSkill.LastSkillUse = DateTime.Now;
CurrentMp -= npcMonsterSkill.Skill.MpCost;
MapInstance.Broadcast(
$"ct 2 {MapNpcId} {(byte)Target.SessionType()} {Target.GetId()} {npcMonsterSkill.Skill.CastAnimation} {npcMonsterSkill.Skill.CastEffect} {npcMonsterSkill.Skill.SkillVNum}");
}
LastMove = DateTime.Now;
BattleEntity.TargetHit(Target, TargetHitType.SingleTargetHit, npcMonsterSkill?.Skill,
Npc.BasicSkill);
}
public HitRequest(TargetHitType singleTargetHit, ClientSession session, Mate attacker, NpcMonsterSkill skill)
{
this.singleTargetHit = singleTargetHit;
this.session = session;
this.attacker = attacker;
this.skill = skill;
}
public HitRequest(TargetHitType targetHitType, ClientSession session, Mate mate, NpcMonsterSkill skill)
{
HitTimestamp = DateTime.Now;
Mate = mate;
NpcMonsterSkill = skill;
TargetHitType = targetHitType;
Session = session;
}
public HitRequest(TargetHitType targetHitType, MapMonster monster, NpcMonsterSkill skill, bool showTargetAnimation = false)
{
HitTimestamp = DateTime.Now;
Monster = monster;
Skill = skill?.Skill;
TargetHitType = targetHitType;
SkillBCards = skill?.Skill.BCards ?? new List <BCard>();
SkillEffect = skill.Skill.Effect;
ShowTargetHitAnimation = showTargetAnimation;
}
/// <summary>
/// Handle any kind of Monster interaction
/// </summary>
private void MonsterLife()
{
if (Monster == null || MapInstance == null)
{
return;
}
ShowEffect();
if (!IsAlive) // Respawn
{
if (ShouldRespawn == null || !ShouldRespawn.Value)
{
Life.Dispose();
}
else if ((DateTime.Now - Death).TotalSeconds >= Monster.RespawnTime / 10d)
{
Respawn();
}
return;
}
if (Target == null) // basic move
{
Move();
return;
}
lock (Target)
{
NpcMonsterSkill npcMonsterSkill = null;
if (ServerManager.Instance.RandomNumber(0, 10) > 8 && Skills != null)
{
npcMonsterSkill = Skills
.Where(s => (DateTime.Now - s.LastSkillUse).TotalMilliseconds >= 100 * s.Skill.Cooldown)
.OrderBy(s => _random.Next()).FirstOrDefault();
}
if (npcMonsterSkill?.Skill.TargetType == 1 && npcMonsterSkill?.Skill.HitType == 0)
{
TargetHit(npcMonsterSkill);
}
// check if target is in range & if monster has enough mp to use the skill
if (IsAlive && Life != null && Target != null && CurrentMp >= (npcMonsterSkill?.Skill?.MpCost ?? CurrentMp) &&
Map.GetDistance(GetPos(), Target.GetPos()) <=
(npcMonsterSkill?.Skill.Range + 1 ?? Monster?.BasicRange))
{
TargetHit(npcMonsterSkill);
return;
}
FollowTarget();
}
}
public static bool ToNpcMonsterSkillDTO(NpcMonsterSkill input, NpcMonsterSkillDTO output)
{
if (input == null)
{
return(false);
}
output.NpcMonsterSkillId = input.NpcMonsterSkillId;
output.NpcMonsterVNum = input.NpcMonsterVNum;
output.Rate = input.Rate;
output.SkillVNum = input.SkillVNum;
return(true);
}
/// <summary>
/// suctl packet
/// </summary>
/// <param name="suctlPacket"></param>
public void Attack(SuctlPacket suctlPacket)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted() && penalty != null)
{
if (Session.Character.Gender == GenderType.Female)
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = Session.Character.Mates.FirstOrDefault(x => x.MateTransportId == suctlPacket.MateTransportId);
if (attacker == null)
{
return;
}
if (attacker.IsSitting)
{
return;
}
IEnumerable <NpcMonsterSkill> mateSkills = attacker.IsUsingSp ? attacker.SpSkills.ToList() : attacker.Monster.Skills;
if (mateSkills != null)
{
NpcMonsterSkill ski = mateSkills.FirstOrDefault(s => s?.Skill?.CastId == suctlPacket.CastId);
switch (suctlPacket.TargetType)
{
case UserType.Monster:
if (attacker.Hp > 0)
{
MapMonster target = Session?.CurrentMapInstance?.GetMonster(suctlPacket.TargetId);
AttackMonster(attacker, ski, target);
}
return;
}
}
}
public void AttackMonster(Mate attacker, NpcMonsterSkill skill, MapMonster target)
{
if (target == null || attacker == null || !target.IsAlive || skill?.Skill?.MpCost > attacker.Mp)
{
return;
}
if (skill == null)
{
skill = new NpcMonsterSkill
{
SkillVNum = attacker.Monster.BasicSkill
};
}
attacker.LastSkillUse = DateTime.Now;
attacker.Mp -= skill.Skill == null ? 0 : skill.Skill.MpCost;
target.Monster.BCards.Where(s => s.CastType == 1).ToList().ForEach(s => s.ApplyBCards(attacker));
Session.CurrentMapInstance?.Broadcast($"ct 2 {attacker.MateTransportId} 3 {target.MapMonsterId} {skill.Skill?.CastAnimation} {skill.Skill?.CastEffect} {skill.Skill?.SkillVNum}");
attacker.BattleEntity.TargetHit(target, TargetHitType.SingleTargetHit, skill.Skill);
}
public void Insert(List <NpcMonsterSkillDTO> skills)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
context.Configuration.AutoDetectChangesEnabled = false;
foreach (NpcMonsterSkillDTO skill in skills)
{
NpcMonsterSkill entity = new NpcMonsterSkill();
Mapper.Mappers.NpcMonsterSkillMapper.ToNpcMonsterSkill(skill, entity);
context.NpcMonsterSkill.Add(entity);
}
context.Configuration.AutoDetectChangesEnabled = true;
context.SaveChanges();
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
public void AttackMonster(Mate attacker, NpcMonsterSkill skill, MapMonster target)
{
if (target == null || attacker == null)
{
return;
}
if (target.CurrentHp > 0)
{
int dmg = 100; //TEST
if (skill == null)
{
Session?.CurrentMapInstance?.Broadcast($"ct 2 {attacker.MateTransportId} 3 {target.MapMonsterId} -1 -1 0");
target.CurrentHp -= dmg;
if (target.CurrentHp <= 0)
{
target.CurrentHp = 0;
target.IsAlive = false;
}
Session?.CurrentMapInstance?.Broadcast($"su 2 {attacker.MateTransportId} 3 {target.MapMonsterId} 0 12 11 200 0 0 {(target.IsAlive ? 1 : 0)} {(int) ((double) target.CurrentHp / target.Monster.MaxHP * 100)} {dmg} 0 0");
}
}
}
public NpcMonsterSkillDTO Insert(ref NpcMonsterSkillDTO npcMonsterSkill)
{
try
{
using (OpenNosContext context = DataAccessHelper.CreateContext())
{
NpcMonsterSkill entity = new NpcMonsterSkill();
Mapper.Mappers.NpcMonsterSkillMapper.ToNpcMonsterSkill(npcMonsterSkill, entity);
context.NpcMonsterSkill.Add(entity);
context.SaveChanges();
if (Mapper.Mappers.NpcMonsterSkillMapper.ToNpcMonsterSkillDTO(entity, npcMonsterSkill))
{
return(npcMonsterSkill);
}
return(null);
}
}
catch (Exception e)
{
Logger.Error(e);
return(null);
}
}
internal static void AttackCharacter(this ClientSession session, Mate attacker, NpcMonsterSkill skill, Character target)
{
if (attacker == null || target == null)
{
return;
}
if (target.Hp > 0 && attacker.Hp > 0)
{
if ((session.CurrentMapInstance.MapInstanceId == ServerManager.Instance.ArenaInstance.MapInstanceId ||
session.CurrentMapInstance.MapInstanceId
== ServerManager.Instance.FamilyArenaInstance.MapInstanceId) &&
(session.CurrentMapInstance.Map.JaggedGrid[session.Character.PositionX][
session.Character.PositionY]?.Value != 0 ||
target.Session.CurrentMapInstance.Map.JaggedGrid[target.PositionX][
target.PositionY]
?.Value != 0))
{
// User in SafeZone
session.SendPacket(StaticPacketHelper.Cancel(2, target.CharacterId));
return;
}
if (target.IsSitting)
{
target.Rest();
}
short castAnimation = -1;
short castEffect = -1;
short skillVnum = 0;
short cooldown = 0;
byte type = 0;
if (skill != null)
{
castAnimation = skill.Skill.CastAnimation;
castEffect = skill.Skill.CastEffect;
skillVnum = skill.SkillVNum;
cooldown = skill.Skill.Cooldown;
type = skill.Skill.Type;
}
var hitmode = 0;
var onyxWings = false;
BattleEntity battleEntity = new BattleEntity(attacker);
BattleEntity battleEntityDefense = new BattleEntity(target);
session.CurrentMapInstance?.Broadcast(StaticPacketHelper.CastOnTarget(UserType.Npc,
attacker.MateTransportId, 3, target.CharacterId, castAnimation, castEffect, skillVnum));
session.CurrentMapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Npc, attacker.MateTransportId, 3, target.CharacterId, skillVnum, cooldown, castAnimation, castEffect, target.MapX, target.MapY, target.Hp > 0, (int)(target.Hp / (double)target.HPMax * 100), 0, 0, type));
var damage = DamageHelper.Instance.CalculateDamage(battleEntity, battleEntityDefense, skill?.Skill,
ref hitmode, ref onyxWings);
if (target.HasGodMode)
{
damage = 0;
hitmode = 1;
}
else if (target.LastPvpRevive > DateTime.Now.AddSeconds(-10) ||
session.Character.LastPvpRevive > DateTime.Now.AddSeconds(-10))
{
damage = 0;
hitmode = 1;
}
int[] manaShield = target.GetBuff(BCardType.CardType.LightAndShadow,
(byte)AdditionalTypes.LightAndShadow.InflictDamageToMP);
if (manaShield[0] != 0 && hitmode != 1)
{
var reduce = damage / 100 * manaShield[0];
if (target.Mp < reduce)
{
target.Mp = 0;
}
else
{
target.Mp -= reduce;
}
}
target.GetDamage(damage / 2);
target.LastDefence = DateTime.Now;
target.Session.SendPacket(target.GenerateStat());
var isAlive = target.Hp > 0;
if (!isAlive && target.Session.HasCurrentMapInstance)
{
if (target.Session.CurrentMapInstance.Map?.MapTypes.Any(
s => s.MapTypeId == (short)MapTypeEnum.Act4)
== true)
{
if (ServerManager.Instance.ChannelId == 51 && ServerManager.Instance.Act4DemonStat.Mode == 0 &&
ServerManager.Instance.Act4AngelStat.Mode == 0)
{
switch (session.Character.Faction)
{
case FactionType.Angel:
ServerManager.Instance.Act4AngelStat.Percentage += 100;
break;
case FactionType.Demon:
ServerManager.Instance.Act4DemonStat.Percentage += 100;
break;
}
}
session.Character.Act4Kill++;
target.Act4Dead++;
target.GetAct4Points(-1);
if (target.Level + 10 >= session.Character.Level &&
session.Character.Level <= target.Level - 10)
{
session.Character.GetAct4Points(2);
}
if (target.Reputation < 50000)
{
target.Session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("LOSE_REP"), 0), 11));
}
else
{
target.Reputation -= target.Level * 50;
session.Character.Reputation += target.Level * 50;
session.SendPacket(session.Character.GenerateLev());
target.Session.SendPacket(target.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("LOSE_REP"),
(short)(target.Level * 50)), 11));
}
foreach (ClientSession sess in ServerManager.Instance.Sessions.Where(
s => s.HasSelectedCharacter))
{
if (sess.Character.Faction == session.Character.Faction)
{
sess.SendPacket(sess.Character.GenerateSay(
string.Format(
Language.Instance.GetMessageFromKey(
$"ACT4_PVP_KILL{(int)target.Faction}"), session.Character.Name),
12));
}
else if (sess.Character.Faction == target.Faction)
{
sess.SendPacket(sess.Character.GenerateSay(
string.Format(
Language.Instance.GetMessageFromKey(
$"ACT4_PVP_DEATH{(int)target.Faction}"), target.Name),
11));
}
}
target.Session.SendPacket(target.GenerateFd());
target.DisableBuffs(BuffType.All, force: true);
target.Session.CurrentMapInstance.Broadcast(target.Session, target.GenerateIn(),
ReceiverType.AllExceptMe);
target.Session.CurrentMapInstance.Broadcast(target.Session, target.GenerateGidx(),
ReceiverType.AllExceptMe);
target.Session.SendPacket(
target.GenerateSay(Language.Instance.GetMessageFromKey("ACT4_PVP_DIE"), 11));
target.Session.SendPacket(
UserInterfaceHelper.GenerateMsg(Language.Instance.GetMessageFromKey("ACT4_PVP_DIE"), 0));
Observable.Timer(TimeSpan.FromMilliseconds(2000)).Subscribe(o =>
{
target.Session.CurrentMapInstance?.Broadcast(target.Session,
$"c_mode 1 {target.CharacterId} 1564 0 0 0");
target.Session.CurrentMapInstance?.Broadcast(target.GenerateRevive());
});
Observable.Timer(TimeSpan.FromMilliseconds(30000)).Subscribe(o =>
{
target.Hp = (int)target.HPLoad();
target.Mp = (int)target.MPLoad();
var x = (short)(39 + ServerManager.RandomNumber <short>(-2, 3));
var y = (short)(42 + ServerManager.RandomNumber <short>(-2, 3));
switch (target.Faction)
{
case FactionType.Angel:
ServerManager.Instance.ChangeMap(target.CharacterId, 130, x, y);
break;
case FactionType.Demon:
ServerManager.Instance.ChangeMap(target.CharacterId, 131, x, y);
break;
default:
{
target.MapId = 145;
target.MapX = 51;
target.MapY = 41;
var connection =
CommunicationServiceClient.Instance.RetrieveOriginWorld(session.Account.AccountId);
if (string.IsNullOrWhiteSpace(connection))
{
return;
}
var port = Convert.ToInt32(connection.Split(':')[1]);
session.Character.ChangeChannel(connection.Split(':')[0], port, 3);
return;
}
}
target.Session.CurrentMapInstance?.Broadcast(target.Session, target.GenerateTp());
target.Session.CurrentMapInstance?.Broadcast(target.GenerateRevive());
target.Session.SendPacket(target.GenerateStat());
});
}
}
if (hitmode != 1)
{
skill?.Skill?.BCards.Where(s => s.Type.Equals((byte)BCardType.CardType.Buff)).ToList()
.ForEach(s => s.ApplyBCards(target, session.Character));
}
session.CurrentMapInstance?.Broadcast(StaticPacketHelper.SkillUsed(UserType.Npc,
attacker.MateTransportId, 1, target.CharacterId, 0, 12, 11, 200, 0, 0, isAlive,
(int)(target.Hp / target.HPLoad() * 100), damage, hitmode, 0));
}
else
{
// monster already has been killed, send cancel
session.SendPacket(StaticPacketHelper.Cancel(2, target.CharacterId));
}
}
public HitRequest(TargetHitType targetHitType, ClientSession session, Mate mate, NpcMonsterSkill skill)
{
HitTimestamp = DateTime.Now;
Mate = mate;
Skill = skill?.Skill;
TargetHitType = targetHitType;
Session = session;
SkillBCards = skill?.Skill.BCards ?? new List <BCard>();
SkillEffect = skill?.Skill.Effect ?? 0;
}
private void ExecuteHandler(ClientSession session)
{
PenaltyLogDTO penalty = session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (session.Character.IsMuted() && penalty != null)
{
if (session.Character.Gender == GenderType.Female)
{
session.CurrentMapInstance?.Broadcast(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"),
(penalty.DateEnd - DateTime.UtcNow).ToString("hh\\:mm\\:ss")), 11));
}
else
{
session.CurrentMapInstance?.Broadcast(
session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
session.SendPacket(session.Character.GenerateSay(
string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"),
(penalty.DateEnd - DateTime.UtcNow).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = session.Character.Mates.First(x => x.MateTransportId == MateTransportId);
if (attacker != null)
{
switch (TargetType)
{
case UserType.Monster:
if (attacker.IsAlive)
{
MapMonster target = session.CurrentMapInstance?.GetMonster(TargetId);
NpcMonsterSkill skill = attacker.Monster.Skills.Find(x => x.NpcMonsterSkillId == CastId);
session.AttackMonster(attacker, skill?.Skill, target);
}
return;
case UserType.Player:
if (attacker.IsAlive)
{
Character target = session.CurrentMapInstance?.GetSessionByCharacterId(TargetId)
?.Character;
if (target != null && session.CurrentMapInstance != null &&
((target.Session.CurrentMapInstance == session.CurrentMapInstance &&
target.CharacterId != session.Character.CharacterId &&
session.CurrentMapInstance.Map.MapTypes.Any(s =>
s.MapTypeId == (short)MapTypeEnum.Act4) && session.Character.Faction
!= target.Faction && session.CurrentMapInstance.Map
.MapId != 130 && session.CurrentMapInstance.Map
.MapId != 131) ||
(session.CurrentMapInstance.Map.MapTypes.Any(m =>
m.MapTypeId == (short)MapTypeEnum.PvpMap) &&
(session.Character.Group?
.IsMemberOfGroup(
target.CharacterId) != true)) ||
(session.CurrentMapInstance.IsPvp && (session.Character.Group?.IsMemberOfGroup(
target.CharacterId) != true))))
{
NpcMonsterSkill skill = attacker.Monster.Skills.Find(x => x.NpcMonsterSkillId == CastId);
session.AttackCharacter(attacker, skill?.Skill, target);
}
}
return;
case UserType.Npc:
case UserType.Object:
return;
}
}
}
/// <summary>
/// u_pet packet
/// </summary>
/// <param name="upetPacket"></param>
public void SpecialSkill(UpetPacket upetPacket)
{
PenaltyLogDTO penalty = Session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (Session.Character.IsMuted() && penalty != null)
{
if (Session.Character.Gender == GenderType.Female)
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
Session.CurrentMapInstance?.Broadcast(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
Session.SendPacket(Session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = Session.Character.Mates.FirstOrDefault(x => x.MateTransportId == upetPacket.MateTransportId);
if (attacker == null)
{
return;
}
NpcMonsterSkill mateSkill = null;
if (attacker.Monster.Skills.Any())
{
mateSkill = attacker.Monster.Skills.FirstOrDefault(x => x.Rate == 0);
}
if (mateSkill == null)
{
mateSkill = new NpcMonsterSkill
{
SkillVNum = 200
};
}
if (attacker.IsSitting)
{
return;
}
switch (upetPacket.TargetType)
{
case UserType.Monster:
if (attacker.Hp > 0)
{
MapMonster target = Session?.CurrentMapInstance?.GetMonster(upetPacket.TargetId);
AttackMonster(attacker, mateSkill, target);
}
return;
case UserType.Npc:
return;
case UserType.Player:
return;
case UserType.Object:
return;
default:
return;
}
}
public void AttackCharacter(Mate attacker, NpcMonsterSkill skill, Character target)
{
}
private void ExecuteHandler(ClientSession session)
{
PenaltyLogDTO penalty = session.Account.PenaltyLogs.OrderByDescending(s => s.DateEnd).FirstOrDefault();
if (session.Character.IsMuted() && penalty != null)
{
if (session.Character.Gender == GenderType.Female)
{
session.CurrentMapInstance?.Broadcast(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_FEMALE"), 1));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
else
{
session.CurrentMapInstance?.Broadcast(session.Character.GenerateSay(Language.Instance.GetMessageFromKey("MUTED_MALE"), 1));
session.SendPacket(session.Character.GenerateSay(string.Format(Language.Instance.GetMessageFromKey("MUTE_TIME"), (penalty.DateEnd - DateTime.Now).ToString("hh\\:mm\\:ss")), 11));
}
return;
}
Mate attacker = session.Character.Mates.FirstOrDefault(x => x.MateTransportId == MateTransportId);
if (attacker == null)
{
return;
}
NpcMonsterSkill mateSkill = null;
if (attacker.Monster.Skills.Any())
{
mateSkill = attacker.Monster.Skills.FirstOrDefault(sk => MateHelper.Instance.PetSkills.Contains(sk.SkillVNum));
}
if (mateSkill == null)
{
mateSkill = new NpcMonsterSkill
{
SkillVNum = 200
};
}
if (attacker.IsSitting)
{
return;
}
MapMonster target = session.CurrentMapInstance?.GetMonster(TargetId);
switch (TargetType)
{
case UserType.Monster:
case UserType.Npc:
if (attacker.Hp <= 0)
{
return;
}
if (target != null)
{
session.CurrentMapInstance.Broadcast(StaticPacketHelper.CastOnTarget(UserType.Npc, attacker.MateTransportId, 3, target.MapMonsterId, mateSkill.Skill.CastAnimation, mateSkill.Skill.CastEffect, mateSkill.SkillVNum));
session.CurrentMapInstance.Broadcast(StaticPacketHelper.SkillUsed(UserType.Npc, attacker.MateTransportId, 3, target.MapMonsterId, mateSkill.SkillVNum, mateSkill.Skill.Cooldown, mateSkill.Skill.AttackAnimation, mateSkill.Skill.Effect, target.MapX, target.MapY, target.CurrentHp > 0, (int)(target.CurrentHp / (double)target.MaxHp * 100), 0, 0, 0));
}
session.AttackMonster(attacker, mateSkill.Skill, TargetId, target?.MapX ?? attacker.PositionX, target?.MapY ?? attacker.PositionY);
session.SendPacketAfter("petsr 0", mateSkill.Skill.Cooldown * 100);
return;
case UserType.Player:
if (attacker.Hp <= 0)
{
return;
}
Character targetChar = session.CurrentMapInstance?.GetSessionByCharacterId(TargetId)
?.Character;
if (targetChar != null && session.CurrentMapInstance != null &&
(targetChar.Session.CurrentMapInstance == session.CurrentMapInstance &&
targetChar.CharacterId != session.Character.CharacterId &&
session.CurrentMapInstance.Map.MapTypes.Any(s =>
s.MapTypeId == (short)MapTypeEnum.Act4) && session.Character.Faction !=
targetChar.Faction && session.CurrentMapInstance.Map
.MapId != 130 && session.CurrentMapInstance.Map
.MapId != 131 ||
session.CurrentMapInstance.Map.MapTypes.Any(m =>
m.MapTypeId == (short)MapTypeEnum.PvpMap) &&
(session.Character.Group == null ||
!session.Character.Group
.IsMemberOfGroup(
targetChar.CharacterId)) ||
session.CurrentMapInstance.IsPvp && (session.Character.Group == null ||
!session.Character.Group.IsMemberOfGroup(
targetChar.CharacterId))))
{
session.AttackCharacter(attacker, mateSkill, targetChar);
}
return;
case UserType.Object:
return;
default:
return;
}
}
