private void calcEffect(L2Character character)
{
if (EffectID != -1)
{
TSkill skill = TSkillTable.getInstance().get(EffectID, EffectLv);
if (skill == null)
{
CLogger.error("ItemHandler: item " + id + " with null effect " + EffectID + "/" + EffectLv);
return;
}
character.addAbnormal(skill, character, true, false);
character.broadcastPacket(new MagicSkillUse(character, character, skill, 100));
}
}
public override async Task DoDieAsync(L2Character killer)
{
await base.DoDieAsync(killer);
if (killer is L2Player)
{
((L2Player)killer).RedistExp(this);
}
//Template.roll_drops(this, killer);
//if (TerritorySpawn != null)
// TerritorySpawn.OnDie(this, killer);
//socialTask.Enabled = false;
}
public static void Process(L2Character character, L2Item item)
{
if (!(character is L2Player) || !Items.ContainsKey(item.Template.ItemId))
{
return;
}
CapsuleItem caps = Items[item.Template.ItemId];
L2Player player = (L2Player)character;
player.DestroyItem(item, 1);
foreach (CapsuleItemReward rew in caps.Rewards.Where(rew => RandomThreadSafe.Instance.Next(100) <= rew.Rate))
{
player.AddItem(rew.Id, RandomThreadSafe.Instance.Next(rew.Min, rew.Max));
}
}
public Die(L2Character cha)
{
_sId = cha.ObjId;
if (cha is L2Player)
{
DiePlayer((L2Player)cha);
}
else
{
if (cha is L2Warrior)
{
_mSpoil = ((L2Warrior)cha).SpoilActive ? 1 : 0;
}
}
}
private void AttackMoveTask(object sender, System.Timers.ElapsedEventArgs e)
{
if (_player.IsAttacking())
{
return;
}
if (_player.Target == null)
{
AttackMove.Enabled = false;
return;
}
double dis = Calcs.CalculateDistance(_player, Character.Target, true);
if (dis < 80)
{
L2Character target = _player.Target;
if (!target.Dead)
{
_player.DoAttack(target);
}
}
else
{
if (_player.CantMove())
{
return;
}
if ((_lastx != _player.Target.X) || (_lasty != _player.Target.Y) || (_lastz != _player.Target.Z))
{
_moveTarget = 0;
}
if (_moveTarget != 0)
{
return;
}
_player.MoveTo(_player.Target.X, _player.Target.Y, _player.Target.Z);
_moveTarget = 1;
_lastx = Character.Target.X;
_lasty = Character.Target.Y;
_lastz = Character.Target.Z;
}
}
public async Task MoveTo(int x, int y, int z)
{
if (!CanMove())
{
_character.SendActionFailedAsync();
return;
}
if (_character.IsAttacking())
{
_character.AbortAttack();
}
if (IsMoving)
{
UpdatePosition();
await NotifyStopMove(false);
}
float dx = x - X;
float dy = y - Y;
float dz = z - Z;
if (dx * dx + dy * dy > 9900 * 9900)
{
_character.SendActionFailedAsync();
return;
}
DestinationX = x;
DestinationY = y;
DestinationZ = z;
Vector2 targetVector = new Vector2(dx, dy);
targetVector /= targetVector.Length();
Heading = (int)(Math.Atan2(-targetVector.X, -targetVector.Y) * 10430.378 + short.MaxValue);
_movementUpdateTime = _movementLastTime = DateTime.UtcNow.Ticks;
_attackTarget = null;
IsMoving = true;
await _character.BroadcastPacketAsync(new CharMoveToLocation(_character));
}
private void AttackMoveTask(object sender, ElapsedEventArgs e)
{
if (_moveHome > 0)
{
ValidateSpawnLocation();
return;
}
if (Character.IsAttacking())
{
return;
}
double dis = Calcs.CalculateDistance(Character, Character.Target, true);
if (dis < 80)
{
_moveTarget = 0;
L2Character target = Character.Target;
Character.DoAttack(target);
}
else
{
if (Character.CantMove())
{
return;
}
if ((Lastx != Character.Target.X) || (Lasty != Character.Target.Y) || (Lastz != Character.Target.Z))
{
_moveTarget = 0;
}
if (_moveTarget != 0)
{
return;
}
_moveTarget = 1;
Character.MoveTo(Character.Target.X, Character.Target.Y, Character.Target.Z);
Lastx = Character.Target.X;
Lasty = Character.Target.Y;
Lastz = Character.Target.Z;
}
}
private void AttackMoveTask(object sender, System.Timers.ElapsedEventArgs e)
{
if (player.isAttacking())
{
return;
}
if (player.CurrentTarget == null)
{
attackMove.Enabled = false;
return;
}
double dis = Calcs.calculateDistance(player, character.CurrentTarget, true);
if (dis < 80)
{
L2Character target = (L2Character)player.CurrentTarget;
if (!target._isDead)
{
player.doAttack(target);
}
}
else
{
if (player.cantMove())
{
return;
}
if (lastx != player.CurrentTarget.X || lasty != player.CurrentTarget.Y || lastz != player.CurrentTarget.Z)
{
MoveTarget = 0;
}
if (MoveTarget == 0)
{
player.MoveTo(player.CurrentTarget.X, player.CurrentTarget.Y, player.CurrentTarget.Z);
MoveTarget = 1;
lastx = character.CurrentTarget.X;
lasty = character.CurrentTarget.Y;
lastz = character.CurrentTarget.Z;
}
}
}
private async Task PerformAutoAttack()
{
// TODO: revalidate that on every attack
int attackSpeed = (int)(470000 / _character.CharacterStat.PAttackSpeed); // TODO: calculate real attack speed
bool dual = true; // is dual weapon, harcode for now
while (IsAttacking && CanAttack())
{
Attack attackPacket = new Attack(_character, GenerateSimpleHit(dual));
if (dual)
{
attackPacket.Hits.Add(GenerateSimpleHit(dual));
}
await _character.BroadcastPacketAsync(attackPacket);
StartAutoAttack();
_target.CharAttack.StartAutoAttack();
await Task.Delay(dual?attackSpeed / 2 : attackSpeed - 5);
if (!IsAttacking || !CanAttack())
{
break;
}
PerformHit(attackPacket.Hits[0]);
if (dual)
{
await Task.Delay(attackSpeed / 2 - 5);
if (!IsAttacking || !CanAttack())
{
break;
}
PerformHit(attackPacket.Hits[1]);
}
}
IsAttacking = false;
_target = null;
}
private void CalcEffect(L2Character character)
{
if (EffectId == -1)
{
return;
}
Skill skill = SkillTable.Instance.Get(EffectId, EffectLv);
if (skill == null)
{
Log.Error($"ItemHandler: item {_id} with null effect {EffectId}/{EffectLv}");
return;
}
character.AddAbnormal(skill, character, true, false);
character.BroadcastPacket(new MagicSkillUse(character, character, skill, 100));
}
public void ReduceHp(double value, L2Character attacker /*, bool awake, bool isDot, bool isHpConsumption*/)
{
if (Character.Dead)
{
return;
}
if (value > 0)
{
SetCurrentHp(Math.Max(CurrentHp - value, 0));
}
if (Character.CurHp < 0.5)
{
Character.AbortAttack();
Character.DoDie(attacker);
}
}
public void DropMe(int x, int y, int z, L2Character dropper, L2Character killer, int seconds)
{
X = x;
Y = y;
Z = z;
DropItem pk = new DropItem(this);
if (dropper != null)
{
Dropper = dropper.ObjId;
}
Location = ItemLocation.Void;
killer?.AddKnownObject(this, pk, true);
L2World.Instance.AddObject(this);
}
public void roll_drops(L2Citizen npc, L2Character killer)
{
if (DropData != null)
{
if (DropData.multidrop.Count > 0)
{
DropData.roll_multidrop(npc, killer);
}
if (DropData.multidrop_ex.Count > 0)
{
DropData.roll_multidrop_ex(npc, killer);
}
if (DropData.qdrop.Count > 0)
{
DropData.roll_qdrop(npc, killer);
}
}
}
public void Use(L2Character character, L2Item item)
{
if (character is L2Player)
{
UsePlayer((L2Player)character, item);
}
else
{
if (character is L2Pet)
{
UsePet((L2Pet)character, item);
}
else
{
Log.Warn($"Unk object {character.Name} tried to use {item.Template.ItemId}");
}
}
}
public async void DoAttack(L2Character target) // TODO: Add skill
{
if (!CanAttack(target) || target == _target)
{
_character.SendActionFailedAsync();
return;
}
if (IsAttacking)
{
await CancelAttack();
}
IsAttacking = true;
_target = target;
_autoAttackTask = Task.Factory.StartNew(PerformAutoAttack); // for bow and melee weapon
}
private void AttackMoveTask(object sender, System.Timers.ElapsedEventArgs e)
{
if (MoveHome > 0)
{
ValidateSpawnLocation();
return;
}
if (character.isAttacking())
{
return;
}
double dis = Calcs.calculateDistance(character, character.CurrentTarget, true);
if (dis < 80)
{
MoveTarget = 0;
L2Character target = (L2Character)character.CurrentTarget;
character.doAttack(target);
}
else
{
if (character.cantMove())
{
return;
}
if (lastx != character.CurrentTarget.X || lasty != character.CurrentTarget.Y || lastz != character.CurrentTarget.Z)
{
MoveTarget = 0;
}
if (MoveTarget == 0)
{
MoveTarget = 1;
character.MoveTo(character.CurrentTarget.X, character.CurrentTarget.Y, character.CurrentTarget.Z);
lastx = character.CurrentTarget.X;
lasty = character.CurrentTarget.Y;
lastz = character.CurrentTarget.Z;
}
}
}
public EffectResult Apply(List <Effect> effects, L2Character caster)
{
EffectResult result = new EffectResult();
foreach (EffectResult ter in effects.Select(effect => effect.OnStart(caster, _owner)))
{
if (result.TotalUi == 0)
{
result.TotalUi = ter.TotalUi;
}
if (ter.Sus != null)
{
result.AddAll(ter.Sus);
}
}
return(result);
}
public static double GetPhysHitDamage(L2Character attacker, L2Character target, double sdef)
{
double atk = attacker.CharacterStat.GetStat(EffectType.PPhysicalAttack);
double def = target.CharacterStat.GetStat(EffectType.PPhysicalDefense);
double basedamage = (70 * atk) / def;
basedamage -= sdef;
if (basedamage < 0)
{
basedamage = 0;
}
int rnddmg = (int)(basedamage * 0.2);
basedamage += Rnd.Next(-rnddmg, rnddmg);
return(basedamage);
}
public static double getPhysHitDamage(L2Character attacker, L2Character target, double sdef)
{
double atk = attacker.CharacterStat.getStat(skills2.TEffectType.p_physical_attack);
double def = target.CharacterStat.getStat(skills2.TEffectType.p_physical_defense);
double basedamage = 70 * atk / def;
basedamage -= sdef;
if (basedamage < 0)
{
basedamage = 0;
}
int rnddmg = (int)(basedamage * 0.2);
basedamage += rnd.Next(-rnddmg, rnddmg);
return(basedamage);
}
public override EffectResult OnStart(L2Character caster, L2Character target)
{
if (!_tempSuccess)
{
return(Nothing);
}
//double shieldDef = Formulas.checkShieldDef(caster, target);
double damage = Formulas.GetPhysSkillHitDamage(caster, target, _power);
caster.SendPacket(new SystemMessage(SystemMessage.SystemMessageId.C1HasGivenC2DamageOfS3).AddPlayerName(caster.Name).AddString(target.Name).AddNumber(damage));
if (target is L2Player)
{
target.SendPacket(new SystemMessage(SystemMessage.SystemMessageId.C1HasReceivedS3DamageFromC2).AddPlayerName(target.Name).AddPlayerName(caster.Name).AddNumber(damage));
}
target.ReduceHp(caster, damage);
return(Nothing);
}
public TEffectResult Apply(List <TEffect> effects, L2Character caster)
{
TEffectResult result = new TEffectResult();
foreach (TEffect effect in effects)
{
TEffectResult ter = effect.onStart(caster, owner);
if (result.TotalUI == 0)
{
result.TotalUI = ter.TotalUI;
}
if (ter.sus != null)
{
result.addAll(ter.sus);
}
}
return(result);
}
public void dropMe(int x, int y, int z, L2Character dropper, L2Character killer, int seconds)
{
X = x;
Y = y;
Z = z;
L2dotNET.Game.network.l2send.DropItem pk = new L2dotNET.Game.network.l2send.DropItem(this);
if (dropper != null)
{
_dropper = dropper.ObjID;
}
Location = L2ItemLocation.ground;
if (killer != null)
{
killer.addKnownObject(this, pk, true);
}
L2World.Instance.RealiseEntry(this, pk, true);
}
public void Process(L2Character character, L2Item item)
{
if (!(character is L2Player))
{
return;
}
if (items.ContainsKey(item.Template.ItemID))
{
CapsuleItem caps = items[item.Template.ItemID];
Random rn = new Random();
((L2Player)character).Inventory.destroyItem(item, 1, true, true);
foreach (CapsuleItemReward rew in caps.rewards)
{
if (rn.Next(100) <= rew.rate)
{
((L2Player)character).addItem(rew.id, rn.Next(rew.min, rew.max));
}
}
}
}
public void Process(L2Character character, L2Item item)
{
if (!(character is L2Player))
{
return;
}
if (!Items.ContainsKey(item.Template.ItemId))
{
return;
}
CapsuleItem caps = Items[item.Template.ItemId];
Random rn = new Random();
((L2Player)character).DestroyItem(item, 1);
foreach (CapsuleItemReward rew in caps.Rewards.Where(rew => rn.Next(100) <= rew.Rate))
{
((L2Player)character).AddItem(rew.Id, rn.Next(rew.Min, rew.Max));
}
}
public void CallSkill(L2Player caster, TSkill skill, L2Character target)
{
if (SkillCast == null)
{
SkillCast = new System.Timers.Timer();
}
this.target = target;
if (skill.skill_hit_time > 0)
{
SkillCast.Interval = skill.skill_hit_time;
SkillCast.Elapsed += new System.Timers.ElapsedEventHandler(SkillCastTask);
SkillCast.Enabled = true;
}
else
{
SkillCastTask(null, null);
}
caster.broadcastPacket(new MagicSkillUse(caster, target, skill, skill.skill_hit_time));
}
public override EffectResult OnStart(L2Character caster, L2Character target)
{
int[] loc = null; //для городов не буду писать, пусть тащит как нуль
if (_region.EqualsIgnoreCase("hideout"))
{
L2Player player = (L2Player)target;
if ((player.ClanId > 0) && (player.Clan.HideoutId > 0))
{
loc = player.Clan.Hideout.ownerLoc;
}
}
//if (loc == null) //ELFOC
// loc = MapRegionTable.getInstance().getRespawn(target.X, target.Y, ((L2Player)target).Karma);
if (loc != null)
{
target.Teleport(loc[0], loc[1], loc[2]);
}
return(Nothing);
}
public override TEffectResult onStart(L2Character caster, world.L2Character target)
{
if (!tempSuccess)
{
return(nothing);
}
double shieldDef = Formulas.checkShieldDef(caster, target);
double damage = Formulas.getPhysSkillHitDamage(caster, target, power);
//$c1 has given $c2 damage of $s3.
caster.sendPacket(new SystemMessage(2261).addPlayerName(caster.Name).addString(target.Name).addNumber(damage));
if (target is L2Player) //$c1 has received $s3 damage from $c2.
{
target.sendPacket(new SystemMessage(2262).addPlayerName(target.Name).addPlayerName(caster.Name).addNumber(damage));
}
target.reduceHp(caster, damage);
return(nothing);
}
public override async Task DoDieAsync(L2Character killer)
{
lock (this)
{
if (Dead)
{
return;
}
CharStatus.SetCurrentHp(0);
Dead = true;
}
//Check For Exp
if (killer is L2Player)
{
((L2Player)killer).AddExpSp(this.Template.Exp, this.Template.Sp, true);
}
Target = null;
await CharMovement.NotifyStopMove(true);
if (IsAttacking())
{
AbortAttack();
}
CharStatus.StopHpMpRegeneration();
await BroadcastPacketAsync(new Die(this));
_spawnTable.RegisterRespawn(spawn);
if (Template.CorpseTime <= 0)
{
return;
}
CorpseTimer = new Timer(Template.CorpseTime * 1000);
CorpseTimer.Elapsed += new ElapsedEventHandler(RemoveCorpse);
CorpseTimer.Start();
}
private void calcSkill(L2Character character)
{
if (SkillID != -1)
{
TSkill skill = TSkillTable.getInstance().get(SkillID, SkillLv);
if (skill == null)
{
CLogger.error("ItemHandler: item " + id + " with null skill " + SkillID + "/" + SkillLv);
return;
}
if (character is L2Player)
{
((L2Player)character).castSkill(skill, false, false);
}
else
{
character.castSkill(skill);
}
}
}
private void affect(L2Character target)
{
target.SendMessage("u can feel defence.");
//Random rn = new Random();
//if (Zone._skills != null)
//{
// foreach (L2Skill sk in Zone._skills)
// {
// if (rn.Next(0, 100) > Zone._skill_prob)
// continue;
// target.addAbnormal(sk, null, true, false);
// }
//}
//if (Zone._skill != null)
//{
// if (rn.Next(0, 100) > Zone._skill_prob)
// return;
// target.addAbnormal(Zone._skill, null, true, false);
//}
}
