public static bool Handle(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (!attacker.Alive)
{
return(false);
}
if (!(attacker is Entities.GameClient))
{
return(false);
}
if (!(attacker as Entities.GameClient).Equipments.Contains(Enums.ItemLocation.WeaponR))
{
return(false);
}
if (!(attacker as Entities.GameClient).Equipments[Enums.ItemLocation.WeaponR].IsBow())
{
return(false);
}
(attacker as Entities.GameClient).AddStatusEffect1(Enums.Effect1.Fly, 40000);
return(true);
}
public static bool FixTarget(Entities.IEntity attacker, Entities.IEntity target)
{
if (attacker is Entities.GameClient && target is Entities.GameClient)
{
if ((attacker as Entities.GameClient).PKMode == Enums.PKMode.Team)
{
if ((attacker as Entities.GameClient).Team != null)
{
if ((attacker as Entities.GameClient).Team.Members.ContainsKey(target.EntityUID))
{
return(false);
}
}
else if ((attacker as Entities.GameClient).Guild != null)
{
if ((attacker as Entities.GameClient).Guild.Members.Contains((target as Entities.GameClient).DatabaseUID))
{
return(false);
}
else if ((attacker as Entities.GameClient).Guild != null)
{
if ((attacker as Entities.GameClient).Guild.IsAllie((target as Entities.GameClient).Guild.Name))
{
return(false);
}
}
}
}
}
return(true);
}
/// <summary>
/// Gets the ranged damage.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="attacked">The attacked.</param>
/// <returns>Returns the damage.</returns>
public static uint GetRangedDamage(Entities.IEntity attacker, Entities.IEntity attacked)
{
double damage = 0;
if (attacker is Entities.GameClient)
{
if (attacked is Entities.GameClient)
{
damage = GetRangedDamage_PVP((attacker as Entities.GameClient), (attacked as Entities.GameClient));
}
if (attacked is Entities.Monster)
{
damage = GetRangedDamage_PVM((attacker as Entities.GameClient), (attacked as Entities.Monster));
}
}
if (damage > 1)
{
if (attacker.Level > (attacked.Level + 10))
{
damage *= 1.25;
}
else if ((attacker.Level + 10) < attacked.Level)
{
damage = (damage * 0.75);
}
}
damage = (damage >= 1 ? damage : 1);
if (damage > 1)
{
damage += ((damage / 2) * attacker.Reborns);
}
return((uint)damage);
}
public async Task Process_CompleteWithError_WhenOutgoingLinkQueueNotFound()
{
const string linkName = "abcd";
const string entity = "entity";
ISecurityContext securityContext = Substitute.For <ISecurityContext>();
IEntityLookup entityLookup = Substitute.For <IEntityLookup>();
ILoggerProvider loggerProvider = Substitute.For <ILoggerProvider>();
Entities.IEntity fakeEntity = Substitute.For <Entities.IEntity>();
var linkProcessor = new LinkProcessor(securityContext, entityLookup, loggerProvider);
fakeEntity.DeliveryQueue.Returns((DeliveryQueue)null);
entityLookup.Find(Arg.Any <string>()).Returns(fakeEntity);
securityContext.IsAuthorized(Arg.Any <Connection>()).Returns(true);
AmqpException exception = null;
Session session = await TestAmqpHost.OpenAndLinkProcessorAsync(linkProcessor);
try
{
var receiver = new ReceiverLink(session, linkName, entity);
Func <Task> action = async() => await receiver.ReceiveAsync();
linkProcessor.ShouldSatisfyAllConditions(
() => exception = action.ShouldThrow <AmqpException>(),
() => exception.Error.Condition.ShouldBe((Symbol)ErrorCode.NotFound),
() => exception.Error.Description.ShouldBe("Queue not found.")
);
}
finally
{
await session.Connection.CloseAsync();
}
}
public static bool Handle(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (!attacker.Alive)
{
return(false);
}
if (target == null)
{
return(false);
}
if (target.Alive)
{
return(false);
}
if (attacker.EntityUID == target.EntityUID)
{
return(false);
}
if (!(target is Entities.GameClient))
{
return(false);
}
Entities.GameClient TargetClient = (target as Entities.GameClient);
TargetClient.ForceRevive();
usespell.AddTarget(TargetClient.EntityUID, 0);
return(true);
}
public async Task Process_CompleteSuccessfully_WhenOutgoingLinkQueueFound()
{
const string linkName = "abcd";
const string entity = "entity";
ISecurityContext securityContext = Substitute.For <ISecurityContext>();
IEntityLookup entityLookup = Substitute.For <IEntityLookup>();
ILoggerProvider loggerProvider = Substitute.For <ILoggerProvider>();
Entities.IEntity fakeEntity = Substitute.For <Entities.IEntity>();
var deliveryQueue = new DeliveryQueue();
var linkProcessor = new LinkProcessor(securityContext, entityLookup, loggerProvider);
entityLookup.Find(Arg.Any <string>()).Returns(fakeEntity);
securityContext.IsAuthorized(Arg.Any <Connection>()).Returns(true);
fakeEntity.DeliveryQueue.Returns(deliveryQueue);
Session session = await TestAmqpHost.OpenAndLinkProcessorAsync(linkProcessor);
try
{
var receiver = new ReceiverLink(session, linkName, entity);
deliveryQueue.Enqueue(new Delivery(new Message {
Properties = new Properties {
MessageId = "msgid6746"
}
}));
Message message = await receiver.ReceiveAsync();
message.Properties.MessageId.ShouldBe("msgid6746");
}
finally
{
await session.Connection.CloseAsync();
}
}
protected override bool ConsisteInsertOrUpdate(Entities.IEntity entity, DbContext context)
{
var ticketContext = (SynsTicketContext)context;
var usuarioEntity = (UsuarioEntity)entity;
var usarioLoginIguais = from a in ticketContext.UsuarioEntity
where a.UsuarioId != usuarioEntity.UsuarioId &&
a.Login.Equals(usuarioEntity.Login)
select a;
var usarioEmailsIguais = from a in ticketContext.UsuarioEntity
where a.UsuarioId != usuarioEntity.UsuarioId &&
a.Email.Equals(usuarioEntity.Email)
select a;
if (usarioLoginIguais.Count() > 0)
{
this.Erros.Add(new TicketException("Campo Login está duplicado"));
}
if (usarioEmailsIguais.Count() > 0)
{
this.Erros.Add(new TicketException("Campo E-mail já Existe"));
}
return(base.ConsisteInsertOrUpdate(entity, context));
}
protected override bool ConsisteInsertOrUpdate(Entities.IEntity entity, DbContext context)
{
var ticketAndamentoContext = (SynsTicketContext)context;
var ticketAdamentoEntity = (TicketAndamentoEntity)entity;
return(base.ConsisteInsertOrUpdate(entity, context));
}
public static void HitDamage(Entities.IEntity attacker, Entities.IEntity attacked, uint damage)
{
attacked.HP -= (int)damage;
if (attacked.HP <= 0)
{
Kill(attacker, attacked, damage);
}
}
public void Add(T newItem)
{
Entities.IEntity newEntity = _mapper.CreateEntityFromDTO(newItem);
Type entityType = newEntity.GetType();
db.Set(entityType).Add(newEntity);
db.SaveChanges();
}
public DTO.IDTOEntity CreateDTOFromEntity(Entities.IEntity entity)
{
Entities.Expense expense = (Entities.Expense)entity;
return(new DTO.Expense()
{
Amount = expense.Amount,
ExpenseDate = expense.ExpenseDate,
Description = expense.Description,
ExpenseGroupId = expense.ExpenseGroupId
});
}
public static bool HandleSelf(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (target != null)
{
if (target is Entities.NPC)
{
return(false);
}
if (target.EntityUID != attacker.EntityUID)
{
return(false);
}
}
if (attacker is Entities.GameClient)
{
Entities.GameClient client = (attacker as Entities.GameClient);
if (!(DateTime.Now >= client.LastSmallLongSkill.AddMilliseconds(Core.TimeIntervals.SmallLongSkillInterval)) && client.AttackPacket == null)
{
using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
client.Send(fmsg);
return(false);
}
client.LastSmallLongSkill = DateTime.Now;
}
if (spell.ID == 1190 || spell.ID == 7016)
{
attacker.HP += spell.Power;
}
else
{
attacker.MP += spell.Power;
}
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)spell.Power, (int)spell.Power * 2);
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
usespell.AddTarget(attacker.EntityUID, spell.Power);
return(true);
}
protected override bool ConsisteInsertOrUpdate(Entities.IEntity entity, DbContext context)
{
var ticketContext = (SynsTicketContext)context;
var ticketAnexoEntity = (TicketAnexoEntity)entity;
var usarioLoginIguais = from a in ticketContext.TicketAnexoEntity
where a.TicketAnexoId != ticketAnexoEntity.TicketAnexoId &&
a.CaminhoArquivo.Equals(ticketAnexoEntity.CaminhoArquivo)
select a;
//if (usarioLoginIguais.Count() > 0)
// this.Erros.Add(new TicketException("Anexo com problemas, id ou caminhos iguais a outro anexo"));
return(base.ConsisteInsertOrUpdate(entity, context));
}
public async Task Process_CompleteSuccessfully_WhenIncomingLinkEntityFound()
{
const string linkName = "abcd";
const string entity = "myEntity";
ISecurityContext securityContext = Substitute.For <ISecurityContext>();
IEntityLookup entityLookup = Substitute.For <IEntityLookup>();
ILoggerProvider loggerProvider = Substitute.For <ILoggerProvider>();
Entities.IEntity fakeEntity = Substitute.For <Entities.IEntity>();
var linkProcessor = new LinkProcessor(securityContext, entityLookup, loggerProvider);
entityLookup.Find(entity).Returns(fakeEntity);
securityContext.IsAuthorized(Arg.Any <Connection>()).Returns(true);
Session session = await TestAmqpHost.OpenAndLinkProcessorAsync(linkProcessor);
try
{
var sender = new SenderLink(session, linkName, entity);
var message = new Message
{
Properties = new Properties {
MessageId = "message173"
},
BodySection = new Data {
Binary = Encoding.UTF8.GetBytes("hello!")
}
};
await sender.SendAsync(message);
fakeEntity
.Received(1)
.Post(Arg.Is <Message>(m => m.Properties.MessageId == "message173"));
}
finally
{
await session.Connection.CloseAsync();
}
}
public static void Handle(Entities.IEntity attacker, InteractionPacket interact)
{
if (interact == null)
{
return;
}
Maps.IMapObject attackermap = attacker as Maps.IMapObject;
if (!attackermap.Screen.ContainsEntity(interact.TargetUID))
{
return;
}
Maps.IMapObject target = null;
if (!attackermap.Screen.GetEntity(interact.TargetUID, out target))
{
return;
}
if (target is Entities.NPC)
{
return;
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return;
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
return;
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return;
}
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return;
}
}
Entities.IEntity targetentity = target as Entities.IEntity;
if (targetentity is Entities.BossMonster)
{
if (!(targetentity as Entities.BossMonster).CanBeAttacked)
{
return;
}
}
if (!Combat.FixTarget(attacker, targetentity))
{
return;
}
if (!Core.Screen.ValidDistance(attackermap.X, attackermap.Y, target.X, target.Y))
{
return;
}
if (!attacker.Alive)
{
return;
}
if (!targetentity.Alive)
{
return;
}
if (attacker is Entities.GameClient)
{
if (!ProcessClient((attacker as Entities.GameClient), interact))
{
return;
}
}
uint damage = Calculations.Battle.GetRangedDamage(attacker, targetentity);
Combat.ProcessDamage(attacker, targetentity, ref damage);
interact.Data = damage;
attacker.Screen.UpdateScreen(interact);
if (attacker is Entities.GameClient)
{
Entities.GameClient attackerclient = attacker as Entities.GameClient;
if (damage > 0)
{
if (!(target is Entities.GameClient))
{
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (targetentity.Level > (attacker.Level + 10))
{
exp *= 2;
}
else if (attacker.Level > (targetentity.Level + 10))
{
exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(1, (int)targetentity.Level);
}
if (interact.WeaponTypeRight > 0)
{
attackerclient.AddProfExp(500, exp); // bow
}
}
}
Data.ItemInfo arrow = attackerclient.Equipments[Enums.ItemLocation.WeaponL];
arrow.CurrentDura--;
Database.CharacterDatabase.SaveEquipment(attackerclient, arrow, Enums.ItemLocation.WeaponL);
arrow.SendPacket(attackerclient, 3);
attackerclient.Send(interact);
//interact.Data = 0;
interact.ActivationType = 0;
interact.ActivationValue = 0;
attackerclient.AttackPacket = interact;
attackerclient.UseAutoAttack(interact);
}
}
public static bool HandleSurrounding(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (target == null)
{
return(false);
}
if (target is Entities.NPC)
{
return(false);
}
if (target is Entities.Monster)
{
if (((byte)(target as Entities.Monster).Behaviour) >= 3)
{
return(false);
}
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return(false);
}
}
if (attacker is Entities.GameClient)
{
Entities.GameClient client = (attacker as Entities.GameClient);
if (!(DateTime.Now >= client.LastSmallLongSkill.AddMilliseconds(Core.TimeIntervals.SmallLongSkillInterval)) && client.AttackPacket == null)
{
using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
client.Send(fmsg);
return(false);
}
client.LastSmallLongSkill = DateTime.Now;
}
target.HP += spell.Power;
uint targetcount = 1;
if (spell.SpellID == 1055)
{
foreach (Maps.IMapObject obj in target.Screen.MapObjects.Values)
{
if (obj == null)
{
continue;
}
if (obj.EntityUID == attacker.EntityUID)
{
continue;
}
if (obj.EntityUID == target.EntityUID)
{
continue;
}
if (obj is Entities.NPC)
{
continue;
}
if (Core.Screen.GetDistance(obj.X, obj.Y, target.X, target.Y) > spell.Distance)
{
continue;
}
if (obj is Entities.Monster)
{
if (((byte)(obj as Entities.Monster).Behaviour) >= 3)
{
continue;
}
}
if (obj is Entities.GameClient)
{
if (!(obj as Entities.GameClient).LoggedIn)
{
continue;
}
}
(obj as Entities.IEntity).HP += spell.Power;
usespell.AddTarget(obj.EntityUID, spell.Power);
targetcount++;
}
}
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)spell.Power, (int)spell.Power * 2);
exp *= targetcount;
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
usespell.AddTarget(target.EntityUID, spell.Power);
return(true);
}
public static void Handle(Entities.IEntity attacker, InteractionPacket interact)
{
if (interact == null)
{
return;
}
Maps.IMapObject attackermap = attacker as Maps.IMapObject;
if (!attackermap.Screen.ContainsEntity(interact.TargetUID))
{
return;
}
Maps.IMapObject target = null;
if (!attackermap.Screen.GetEntity(interact.TargetUID, out target))
{
return;
}
if (target is Entities.NPC)
{
return;
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return;
}
if ((target as Entities.GameClient).ContainsFlag1(Enums.Effect1.Fly))
{
return;
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
return;
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return;
}
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return;
}
}
Entities.IEntity targetentity = target as Entities.IEntity;
if (targetentity is Entities.BossMonster)
{
if (!(targetentity as Entities.BossMonster).CanBeAttacked)
{
return;
}
}
if (!Core.Screen.ValidDistance(attackermap.X, attackermap.Y, target.X, target.Y))
{
return;
}
if (!attacker.Alive)
{
return;
}
if (!targetentity.Alive)
{
return;
}
if (attacker is Entities.GameClient)
{
if (!ProcessClient((attacker as Entities.GameClient), interact))
{
return;
}
}
uint damage = Calculations.Battle.GetPhysicalDamage(attacker, targetentity);
Combat.ProcessDamage(attacker, targetentity, ref damage);
if (damage > 0)
{
if (attacker is Entities.GameClient && !(target is Entities.GameClient))
{
Entities.GameClient client = attacker as Entities.GameClient;
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (targetentity.Level > (attacker.Level + 10))
{
exp *= 2;
}
else if (attacker.Level > (targetentity.Level + 10))
{
exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(1, (int)targetentity.Level);
}
if (interact.WeaponTypeRight > 0)
{
client.AddProfExp(interact.WeaponTypeRight, exp);
}
if (interact.WeaponTypeLeft > 0)
{
client.AddProfExp(interact.WeaponTypeLeft, exp);
}
}
}
interact.Data = damage;
attacker.Screen.UpdateScreen(interact);
if (attacker is Entities.GameClient)
{
(attacker as Entities.GameClient).Send(interact);
}
}
public void BeginJumpBot(Entities.GameClient target)
{
Threads.BotThread.Bots.TryAdd(Original.EntityUID, this);
Target = target;
}
public static void Handle(Entities.IEntity attacker, InteractionPacket interact)
{
if (interact == null)
{
return;
}
ConcurrentBag <Entities.IEntity> targets = new ConcurrentBag <ProjectX_V3_Game.Entities.IEntity>();
Maps.IMapObject attackermap = attacker as Maps.IMapObject;
if (!Core.Screen.ValidDistance(attackermap.X, attackermap.Y, interact.X, interact.Y))
{
return;
}
// if (!attackermap.Screen.ContainsEntity(interact.TargetUID))
// {
// return;
// }
// Maps.IMapObject target = null;
// if (!attackermap.Screen.GetEntity(interact.TargetUID, out target))
// {
// return;
// }
// Entities.IEntity targetentity = target as Entities.IEntity;
// if (!Core.Screen.ValidDistance(attackermap.X, attackermap.Y, target.X, target.Y))
// {
// return;
// }
if (!attacker.Alive)
{
return;
}
Maps.IMapObject target = null;
if (interact.TargetUID > 0)
{
if (!attackermap.Screen.GetEntity(interact.TargetUID, out target) && interact.TargetUID != attacker.EntityUID)
{
return; // fail here
}
}
if (target != null)
{
if (target is Entities.NPC)
{
return;
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return;
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
if (interact.MagicType != 1045 && interact.MagicType != 1046)
{
return;
}
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return;
}
// check if revive skill here and above as well!
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return;
}
}
Entities.IEntity targetentity = target as Entities.IEntity;
if (!Core.Screen.ValidDistance(attackermap.X, attackermap.Y, target.X, target.Y))
{
return;
}
if (!Combat.FixTarget(attacker, targetentity))
{
return;
}
if (!targetentity.Alive && interact.MagicType != 1100 && interact.MagicType != 1050)
{
return;
}
}
UseSpellPacket usespell = new UseSpellPacket();
usespell.EntityUID = attacker.EntityUID;
usespell.SpellID = interact.MagicType;
usespell.SpellX = interact.X;
usespell.SpellY = interact.Y;
usespell.SpellLevel = 0;
Data.Spell spell = null;
if (attacker is Entities.GameClient)
{
if (!(attacker as Entities.GameClient).IsAIBot)
{
if (!ProcessClient((attacker as Entities.GameClient), interact, usespell, out spell))
{
return;
}
}
else
{
usespell.SpellLevel = interact.MagicLevel;
spell = Core.Kernel.SpellInfos[usespell.SpellID][(byte)usespell.SpellLevel];
}
}
else if (attacker is Entities.Monster)
{
if (Core.Kernel.SpellInfos.ContainsKey(interact.MagicType))
{
byte maxlevel = (byte)Core.Kernel.SpellInfos[interact.MagicType].Keys.Count;
maxlevel--;
if (Core.Kernel.SpellInfos[interact.MagicType].ContainsKey(maxlevel))
{
spell = Core.Kernel.SpellInfos[interact.MagicType][maxlevel];
}
}
}
// AI
// Guards
// Mobs with skills ??
if (spell == null)
{
return;
}
if (interact.EntityUID != attacker.EntityUID && target != null)
{
usespell.SpellX = target.X;
usespell.SpellY = target.Y;
}
if (spell.UseEP > 0)
{
if (attacker is Entities.GameClient)
{
if (!(attacker as Entities.GameClient).IsAIBot)
{
if (spell.ID == 7001)
{
if (!(attacker as Entities.GameClient).ContainsFlag1(Enums.Effect1.Riding))
{
if ((attacker as Entities.GameClient).Stamina < spell.UseEP)
{
return;
}
}
}
else
if ((attacker as Entities.GameClient).Stamina < spell.UseEP)
{
return;
}
}
}
}
if (spell.UseMP > 0)
{
if (attacker is Entities.Monster)
{
if (attacker.MP < spell.UseMP && ((byte)(attacker as Entities.Monster).Behaviour) < 3)
{
return;
}
}
else if (attacker.MP < spell.UseMP)
{
return;
}
}
bool success = false;
uint damage = 0;
if (attacker.Map == null)
{
return;
}
if (attacker.Map.MapType == Enums.MapType.Tournament)
{
if (interact.MagicType != 1045 && interact.MagicType != 1046)
{
return;
}
}
bool singleSkill = false;
switch (interact.MagicType)
{
#region Line Skills
case 1045:
case 1046:
case 11005:
case 11000:
success = Skills.LineSkills.Handle(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#region SectorSkills
#region Physical
case 1250:
case 5050:
case 5020:
case 1300:
success = Skills.SectoreSkills.HandlePhy(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#region Magic
case 1165:
case 7014:
success = Skills.SectoreSkills.HandleMag(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#endregion
#region Single
#region Magic
case 10310:
case 1000:
case 1001:
case 1002:
case 1150:
case 1160:
case 1180:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.Single.HandleMag(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region Physical
case 1290:
case 5030:
case 5040:
case 7000:
case 7010:
case 7030:
case 7040:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.Single.HandlePhys(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#endregion
#region Circle
#region Physical
case 5010:
case 7020:
case 1115: //herc
success = Skills.CircleSkills.HandlePhy(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#region Magic
case 1010: //lightning tao
case 1120: //fc
case 1125: //volc
case 3090: //pervade
case 5001: //speed
case 8030: //arrows
case 7013: //flame shower
case 30011: //small ice circle
case 30012: //large ice circle
case 10360:
case 10361:
case 10392:
case 10308:
success = Skills.CircleSkills.HandleMag(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#endregion
#region MountSkill
case 7001:
singleSkill = true;
if (attacker is Entities.GameClient)
{
success = Skills.MountSkill.Handle((attacker as Entities.GameClient), usespell);
}
else
{
success = false;
}
break;
#endregion
#region Buff
case 1075:
case 1085:
case 1090:
case 1095:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.BuffSkills.Handle(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region Revive
case 1050:
case 1100:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.ReviveSkills.Handle(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region Fly
case 8002:
case 8003:
singleSkill = true;
success = Skills.FlySkill.Handle(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region Scatter
case 8001:
success = Skills.ScatterSkill.Handle(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#region Cure
#region Self
case 1190:
case 1195:
case 7016:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.CureSkills.HandleSelf(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region Surroundings
case 1005:
case 1055:
case 1170:
case 1175:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.CureSkills.HandleSurrounding(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#endregion
#region Archer
case 10313:
case 8000:
case 9991:
case 7012:
case 7015:
case 7017:
case 1320:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.ArcherSkills.Handle(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region Ninja
#region Toxic Fog
case 6001:
success = Skills.NinjaSkills.HandlePoison(attacker, targets, interact, usespell, spell, out damage);
break;
#endregion
#region TwoFold
case 6000:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.NinjaSkills.HandleTwoFold(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region PoisonStar
case 6002:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.NinjaSkills.HandlePoisonStar(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#region ArcherBane
case 6004:
if (target == null)
{
return;
}
singleSkill = true;
success = Skills.NinjaSkills.HandleArcherBane(attacker, (target as Entities.IEntity), interact, usespell, spell, out damage);
break;
#endregion
#endregion
default:
if (attacker is Entities.GameClient)
{
Entities.GameClient client = (attacker as Entities.GameClient);
using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.INVALID_SKILL))
client.Send(fmsg);
}
return;
}
if (success)
{
if (spell.UseEP > 0)
{
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Stamina >= spell.UseEP)
{
(attacker as Entities.GameClient).Stamina -= spell.UseEP;
}
}
}
if (spell.UseMP > 0)
{
if (attacker.MP >= spell.UseMP)
{
attacker.MP -= spell.UseMP;
}
}
// if (spell.UseItemNum == 0) // fix
// {
// if (attacker is Entities.GameClient)
// {
// Entities.GameClient client = attacker as Entities.GameClient;
// if (!client.Equipments.Contains(Enums.ItemLocation.WeaponL))
// return;
// if (!client.Equipments[Enums.ItemLocation.WeaponL].IsArrow())
// return;
// if (client.Equipments[Enums.ItemLocation.WeaponL].CurrentDura == 0)
// {
// uint arrowtype = client.Equipments[Enums.ItemLocation.WeaponL].ItemID;
// if (client.Inventory.ContainsByID(arrowtype))
// {
// Data.ItemInfo arrow = client.Inventory.SearchForNonEmpty(arrowtype);
// if (arrow != null)
// {
// if (!client.Equipments.Equip(arrow, Enums.ItemLocation.WeaponL, true))
// {
// using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.AUTO_RELOAD_ARROW_FAIL))
// client.Send(fmsg);
// return;
// }
// }
// else
// return;
// }
// else if (!client.Equipments.Unequip(Enums.ItemLocation.WeaponL))
// {
// using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.EMPTY_ARROWS))
// client.Send(fmsg);
// return;
// }
// else
// return; // no more arrows in inventory
// }
// }
// }
//
attacker.Screen.UpdateScreen(usespell);
Entities.IEntity targetentity = target as Entities.IEntity;
if (targetentity != null && singleSkill)
{
if (targetentity.EntityUID != attacker.EntityUID)
{
Combat.HitDamage(attacker, targetentity, damage);
}
else if (targets.Count > 0)
{
foreach (Entities.IEntity targete in targets)
{
Combat.HitDamage(attacker, targete, damage);
}
}
}
else if (targets.Count > 0)
{
foreach (Entities.IEntity targete in targets)
{
Combat.HitDamage(attacker, targete, damage);
}
}
if (attacker is Entities.GameClient)
{
Entities.GameClient attackerclient = attacker as Entities.GameClient;
attackerclient.Send(usespell);
if (usespell.SpellID >= 1000 && usespell.SpellID <= 1002)
{
//interact.Data = 0;
interact.ActivationType = 0;
interact.ActivationValue = 0;
attackerclient.AttackPacket = interact;
attackerclient.UseAutoAttack(interact);
}
}
}
}
/// <summary>
/// Kills an entity.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="attacked">The attacked.</param>
public static void Kill(Entities.IEntity attacker, Entities.IEntity attacked, uint damage = 0)
{
attacked.HP = 0;
attacked.Alive = false;
if (attacked is Entities.Monster)
{
(attacked as Entities.Monster).Kill(attacker, damage);
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Battle != null)
{
(attacker as Entities.GameClient).Battle.KillMob((attacker as Entities.GameClient), attacked.EntityUID);
}
}
}
using (var killpacket = new Packets.InteractionPacket())
{
killpacket.Action = Enums.InteractAction.Kill;
killpacket.TargetUID = attacked.EntityUID;
killpacket.X = attacked.X;
killpacket.Y = attacked.Y;
killpacket.Data = 1;
if (attacker != null)
{
killpacket.EntityUID = attacker.EntityUID;
attacker.Screen.UpdateScreen(killpacket);
if (attacker is Entities.GameClient)
{
(attacker as Entities.GameClient).Send(killpacket);
}
}
else
{
killpacket.EntityUID = 0;
attacked.Screen.UpdateScreen(killpacket);
if (attacked is Entities.GameClient)
{
(attacked as Entities.GameClient).Send(killpacket);
}
}
}
if (attacked is Entities.GameClient)
{
Entities.GameClient attackedclient = attacked as Entities.GameClient;
attackedclient.RemoveFlag1(Enums.Effect1.Fly);
attackedclient.RemoveFlag1(Enums.Effect1.Invisible);
if (attacker != null)
{
if (attacked.EntityUID != attacker.EntityUID)
{
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).Battle != null)
{
if (!(attacker as Entities.GameClient).Battle.HandleDeath((attacker as Entities.GameClient), attackedclient))
{
return;
}
}
else if (attacked.Map.GotKillCons())
{
Entities.GameClient attackerclient = attacker as Entities.GameClient;
if (attackedclient.Guild != null && attackerclient.Guild != null)
{
if (attackerclient.Guild.IsEnemy(attackedclient.Guild.Name))
{
attackerclient.PKPoints += 3;
}
else
{
attackerclient.PKPoints += 10;
}
}
else
{
attackerclient.PKPoints += 10;
}
}
}
}
}
attackedclient.AttackPacket = null;
attackedclient.ReviveTime = DateTime.Now.AddSeconds(20);
attackedclient.AddStatusEffect1(Enums.Effect1.Dead);
attackedclient.AddStatusEffect1(Enums.Effect1.Ghost);
attackedclient.RemoveFlag1(Enums.Effect1.BlueName);
attackedclient.Stamina = 0;
attackedclient.Transformation = Calculations.BasicCalculations.GetGhostTransform(attackedclient.Model);
}
if (attacked is Entities.BossCreature)
{
Entities.BossCreature creature = attacked as Entities.BossCreature;
creature.Abort();
}
else if (attacked is Entities.BossMonster)
{
Entities.BossMonster boss = attacked as Entities.BossMonster;
boss.AbortBoss(false);
if (attacker is Entities.GameClient)
{
boss.ON_DEATH(attacker as Entities.GameClient);
}
}
}
private void Jump_Action()
{
if (Original.WasInArena)
{
Original.WasInArena = false;
Target = null;
Dispose();
return;
}
if (Target == null)
{
return;
}
if (!Original.Alive)
{
Original.Revive();
return;
}
bool CanFB = true;
//if (Calculations.BasicCalculations.ChanceSuccess(95))
//{
if (Core.Screen.GetDistance(Original.X, Original.Y, Target.X, Target.Y) > 15)
{
Enums.ConquerAngle angle = Core.Screen.GetFacing(Core.Screen.GetAngle(Original.X, Original.Y, Target.X, Target.Y));
ushort size = (ushort)Core.Screen.GetDistance(Target.X, Target.Y, Original.X, Original.Y);
size /= 3;
CanFB = false;
Jump(size, angle);
}
else
{
ushort size = (ushort)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(10);
Enums.ConquerAngle angle = (Enums.ConquerAngle)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(8);
Jump(size, angle);
}
/*}
* else
* {
* Packets.GeneralDataPacket general = new ProjectX_V3_Game.Packets.GeneralDataPacket(Enums.DataAction.ChangeAction);
* general.Id = Original.EntityUID;
* general.Data1 = (uint)Enums.ActionType.Sit;
* general.Timestamp = ProjectX_V3_Lib.Native.Winmm.timeGetTime();
* Original.SendToScreen(general, false, false);
* }*/
if (Original.ArenaMatch != null)
{
if (!Original.ArenaMatch.MatchStarted)
{
CanFB = false;
}
}
if (Calculations.BasicCalculations.ChanceSuccess(ShootChance) && CanFB)
{
if (Core.Screen.GetDistance(Original.X, Original.Y, Target.X, Target.Y) <= 10)
{
#region fb / ss
Shoot(Accuracy);
#endregion
}
}
}
/// <summary>
/// Handles the twofold attack skills.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="target">The target.</param>
/// <param name="interaction">The interaction packet.</param>
/// <param name="usespell">The usespell packet.</param>
/// <param name="spell">The spell.</param>
/// <param name="damage">The damage.</param>
/// <returns>Returns true if the skill was used successfully.</returns>
public static bool HandleTwoFold(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (attacker.EntityUID == target.EntityUID)
{
return(false);
}
if (target is Entities.NPC)
{
return(false);
}
if (target is Entities.BossMonster)
{
if (!(target as Entities.BossMonster).CanBeAttacked)
{
return(false);
}
}
if (target is Entities.Monster)
{
if (((byte)(target as Entities.Monster).Behaviour) >= 3)
{
return(false);
}
}
if (Core.Screen.GetDistance(target.X, target.Y, attacker.X, attacker.Y) > spell.Distance)
{
return(false);
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return(false);
}
if ((target as Entities.GameClient).ContainsFlag1(Enums.Effect1.Fly))
{
return(false);
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return(false);
}
if (!Combat.FixTarget(attacker, target))
{
return(false);
}
}
damage = Calculations.Battle.GetPhysicalMagicDamage(attacker, target, spell);
damage = (uint)((damage / 100) * (spell.Power - 30000));
Combat.ProcessDamage(attacker, target, ref damage, false);
if (damage > 0)
{
if (!(target is Entities.GameClient))
{
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (target.Level > (attacker.Level + 10))
{
exp *= 2;
}
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
}
usespell.AddTarget(target.EntityUID, damage);
}
return(true);
}
public static bool Handle(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (!attacker.Alive)
{
return(false);
}
if (target == null)
{
return(false);
}
if (!target.Alive)
{
return(false);
}
if (!(target is Entities.GameClient))
{
return(false);
}
if (attacker is Entities.GameClient)
{
Entities.GameClient client = (attacker as Entities.GameClient);
if (!(DateTime.Now >= client.LastSmallLongSkill.AddMilliseconds(Core.TimeIntervals.SmallLongSkillInterval)) && client.AttackPacket == null)
{
using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
client.Send(fmsg);
return(false);
}
client.LastSmallLongSkill = DateTime.Now;
}
Entities.GameClient TargetClient = (target as Entities.GameClient);
if (!TargetClient.LoggedIn)
{
return(false);
}
switch (spell.SpellID)
{
case 1075:
TargetClient.AddStatusEffect1(Enums.Effect1.PartiallyInvisible, spell.Duration * 1000);
break;
case 1085:
TargetClient.AddStatusEffect1(Enums.Effect1.StarOfAccuracy, spell.Duration * 1000);
break;
case 1090:
TargetClient.AddStatusEffect1(Enums.Effect1.Shield, spell.Duration * 1000);
break;
case 1095:
TargetClient.AddStatusEffect1(Enums.Effect1.Stig, spell.Duration * 1000);
break;
default:
return(false);
}
byte level_target = (byte)(TargetClient.Level > 50 ? 50 : TargetClient.Level);
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)level_target, (int)level_target * 2);
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
usespell.AddTarget(TargetClient.EntityUID, damage);
return(true);
}
/// <summary>
/// Handles the sector skills.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="targets">The targets. [not set yet]</param>
/// <param name="interaction">The interaction packet.</param>
/// <param name="usespell">The usespell packet.</param>
/// <param name="spell">The spell.</param>
/// <param name="damage">The damage.</param>
/// <returns>Returns true if the skill was used successfully.</returns>
public static bool HandlePhy(Entities.IEntity attacker, ConcurrentBag <Entities.IEntity> targets, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
bool self = (interaction.TargetUID == attacker.EntityUID);
if (self)
{
return(false);
}
/*Calculations.InLineAlgorithm ila = new ProjectX_V3_Game.Calculations.InLineAlgorithm(
* attacker.X, interaction.X, attacker.Y, interaction.Y,
* (byte)spell.Range, Calculations.InLineAlgorithm.Algorithm.DDA);*/
Calculations.Sector sector = new ProjectX_V3_Game.Calculations.Sector(attacker.X, attacker.Y, interaction.X, interaction.Y);
sector.Arrange(spell.Sector, spell.Range);
byte count = 0;
bool bluename = false;
foreach (Maps.IMapObject obj in attacker.Screen.MapObjects.Values)
{
if (count > 28)
{
return(true);
}
if (!(obj as Entities.IEntity).Alive)
{
continue;
}
if (obj is Entities.NPC)
{
continue;
}
if (obj.EntityUID == attacker.EntityUID)
{
continue;
}
if (obj is Entities.BossMonster)
{
if (!(obj as Entities.BossMonster).CanBeAttacked)
{
continue;
}
}
if (obj is Entities.Monster)
{
if (((byte)(obj as Entities.Monster).Behaviour) >= 3)
{
continue;
}
}
if (obj is Entities.GameClient)
{
if (!(obj as Entities.GameClient).LoggedIn)
{
continue;
}
if ((obj as Entities.GameClient).ContainsFlag1(Enums.Effect1.Fly))
{
continue;
}
if (obj.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
continue;
}
if (attacker is Entities.GameClient)
{
if ((attacker as Entities.GameClient).PKMode != Enums.PKMode.PK)
{
continue;
}
if (!Combat.FixTarget(attacker, obj as Entities.IEntity))
{
continue;
}
}
if (!(DateTime.Now >= (obj as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
continue;
}
if (!(DateTime.Now >= (obj as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
continue;
}
if (!Combat.FixTarget(attacker, (obj as Entities.GameClient)))
{
continue;
}
if ((obj as Entities.GameClient).ContainsFlag1(Enums.Effect1.BlueName))
{
bluename = true;
}
}
//if (!ila.InLine(obj.X, obj.Y))
// continue;
if (!sector.Inside(obj.X, obj.Y))
{
continue;
}
Entities.IEntity targetentity = obj as Entities.IEntity;
damage = Calculations.Battle.GetPhysicalDamage(attacker, targetentity);
Combat.ProcessDamage(attacker, targetentity, ref damage, false);
if (damage > 0)
{
if (!(targetentity is Entities.GameClient))
{
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (targetentity.Level > (attacker.Level + 10))
{
exp *= 2;
}
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
}
usespell.AddTarget(targetentity.EntityUID, damage);
targets.Add(targetentity);
}
count++;
}
if (attacker is Entities.GameClient && bluename)
{
(attacker as Entities.GameClient).AddStatusEffect1(Enums.Effect1.BlueName, 10000);
}
return(true);
}
/// <summary>
/// Handles the archerbane attack skills.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="target">The target.</param>
/// <param name="interaction">The interaction packet.</param>
/// <param name="usespell">The usespell packet.</param>
/// <param name="spell">The spell.</param>
/// <param name="damage">The damage.</param>
/// <returns>Returns true if the skill was used successfully.</returns>
public static bool HandleArcherBane(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (attacker.EntityUID == target.EntityUID)
{
return(false);
}
if (!(target is Entities.GameClient))
{
return(false);
}
if (!(target as Entities.GameClient).ContainsFlag1(Enums.Effect1.Fly))
{
return(false);
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return(false);
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return(false);
}
if (!Combat.FixTarget(attacker, target))
{
return(false);
}
}
(target as Entities.GameClient).RemoveFlag1(Enums.Effect1.Fly);
//damage = Calculations.Battle.GetPhysicalMagicDamage(attacker, target, spell);
damage = (uint)(target.HP / 10);
Combat.ProcessDamage(attacker, target, ref damage, false);
if (damage > 0)
{
if (!(target is Entities.GameClient))
{
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (target.Level > (attacker.Level + 10))
{
exp *= 2;
}
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
}
}
usespell.AddTarget(target.EntityUID, damage);
return(true);
}
/// <summary>
/// Handles the poisonstar attack skills.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="target">The target.</param>
/// <param name="interaction">The interaction packet.</param>
/// <param name="usespell">The usespell packet.</param>
/// <param name="spell">The spell.</param>
/// <param name="damage">The damage.</param>
/// <returns>Returns true if the skill was used successfully.</returns>
public static bool HandlePoisonStar(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (attacker.EntityUID == target.EntityUID)
{
return(false);
}
if (!(target is Entities.GameClient))
{
return(false);
}
if ((target as Entities.GameClient).ContainsFlag1(Enums.Effect1.Fly))
{
return(false);
}
if (Core.Screen.GetDistance(target.X, target.Y, attacker.X, attacker.Y) > spell.Distance)
{
return(false);
}
if (attacker is Entities.GameClient)
{
Entities.GameClient client = (attacker as Entities.GameClient);
if (!(DateTime.Now >= client.LastSmallLongSkill.AddMilliseconds(Core.TimeIntervals.SmallLongSkillInterval)) && client.AttackPacket == null)
{
using (var fmsg = Packets.Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.REST))
client.Send(fmsg);
return(false);
}
client.LastSmallLongSkill = DateTime.Now;
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return(false);
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return(false);
}
if (!Combat.FixTarget(attacker, target))
{
return(false);
}
}
(target as Entities.GameClient).AddStatusEffect1(Enums.Effect1.NoPotion, (5000 * (spell.Level + 1)));
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)target.Level, (int)target.Level * 2);
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
usespell.AddTarget(target.EntityUID, 0);
return(true);
}
/// <summary>
/// Handles the single attack skills.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="target">The target.</param>
/// <param name="interaction">The interaction packet.</param>
/// <param name="usespell">The usespell packet.</param>
/// <param name="spell">The spell.</param>
/// <param name="damage">The damage.</param>
/// <returns>Returns true if the skill was used successfully.</returns>
public static bool Handle(Entities.IEntity attacker, Entities.IEntity target, InteractionPacket interaction, UseSpellPacket usespell, Data.Spell spell, out uint damage)
{
damage = 0;
if (attacker is Entities.GameClient)
{
if (!Ranged.ProcessClient(attacker as Entities.GameClient, interaction, true))
{
return(false);
}
}
if (attacker.EntityUID == target.EntityUID)
{
return(false);
}
if (target is Entities.NPC)
{
return(false);
}
if (target is Entities.BossMonster)
{
if (!(target as Entities.BossMonster).CanBeAttacked)
{
return(false);
}
}
if (target is Entities.Monster)
{
if (((byte)(target as Entities.Monster).Behaviour) >= 3)
{
return(false);
}
}
if (target is Entities.GameClient)
{
if (!(target as Entities.GameClient).LoggedIn)
{
return(false);
}
if (target.Map.MapType == Enums.MapType.NoPK && (attacker is Entities.GameClient))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).LoginProtection.AddSeconds(10)))
{
return(false);
}
if (!(DateTime.Now >= (target as Entities.GameClient).ReviveProtection.AddSeconds(5)))
{
return(false);
}
if (!Combat.FixTarget(attacker, target))
{
return(false);
}
}
if (attacker is Entities.GameClient)
{
Ranged.DecreaseArrows(attacker as Entities.GameClient, 1);
}
damage = Calculations.Battle.GetRangedDamage(attacker, target);
damage = (uint)(damage * 1.5);
Combat.ProcessDamage(attacker, target, ref damage, false);
if (damage > 0)
{
if (!(target is Entities.GameClient))
{
uint exp = (uint)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (target.Level > (attacker.Level + 10))
{
exp *= 2;
}
if ((attacker is Entities.GameClient))
{
(attacker as Entities.GameClient).AddSpellExp(spell.SpellID, exp);
}
}
usespell.AddTarget(target.EntityUID, damage);
}
return(true);
}
/// <summary>
/// Processing damage.
/// </summary>
/// <param name="attacker">The attacker.</param>
/// <param name="attacked">The attacked.</param>
/// <param name="damage">The damage.</param>
public static void ProcessDamage(Entities.IEntity attacker, Entities.IEntity attacked, ref uint damage, bool kill_damage = true)
{
// Removed dura, bugged atm. the dura works, although client doesn't update proper etc. CBA to fix it as I never intended to use it
// Although you can go ahead and fix it yourself if you want, I may do it if I ever feel like it
// The dura lose is commented out below.
#region ATTACKER : GAMECLIENT
if (attacker is Entities.GameClient)
{
Entities.GameClient attackerclient = attacker as Entities.GameClient;
attackerclient.LoseAttackDura(damage);
#region ATTACKED : GAMECLIENT
if (attacked is Entities.GameClient)
{
Entities.GameClient attackedclient = attacked as Entities.GameClient;
// tournament check, damage = 1 + return
if (attackerclient.Battle != null)
{
if (!attackerclient.Battle.HandleAttack(attackerclient, attackedclient, ref damage))
{
damage = 0;
return;
}
}
else
{
if (attacked.Map.GotKillCons() && !attackedclient.ContainsFlag1(Enums.Effect1.BlueName) && !attackedclient.ContainsFlag1(Enums.Effect1.RedName) && !attackedclient.ContainsFlag1(Enums.Effect1.BlackName))
{
attackerclient.AddStatusEffect1(Enums.Effect1.BlueName, 20000);
}
attackedclient.LoseDefenseDura(damage);
}
}
#endregion
#region ATTACKED : MONSTER
if (attacked is Entities.Monster)
{
Entities.Monster attackedmob = attacked as Entities.Monster;
if (((byte)attackedmob.Behaviour) >= 3)
{
attackerclient.AddStatusEffect1(Enums.Effect1.BlueName, 20000);
}
if (damage > 0)
{
ulong exp = (ulong)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next((int)(damage / 2), (int)damage);
if (attacked.Level > (attacker.Level + 10))
{
exp *= 2;
}
else if (attacker.Level > (attacked.Level + 10))
{
exp = (ulong)ProjectX_V3_Lib.ThreadSafe.RandomGenerator.Generator.Next(1, (int)attackedmob.Level);
}
attackerclient.AddExp(exp);
}
}
#endregion
//if (Calculations.Battle.LoseDuraAttak())
//attackerclient.LoseAttackDura(damage);
}
#endregion
#region ATTACKER : MONSTER
#region ATTACKED : GAMECLIENT
if (attacked is Entities.GameClient)
{
Entities.GameClient attackedclient = attacked as Entities.GameClient;
attackedclient.LoseDefenseDura(damage);
}
#endregion
#endregion
if (kill_damage)
{
HitDamage(attacker, attacked, damage);
}
}
