/// <summary>
/// Uses an item from the player's inventory.
/// </summary>
/// <param name="player">Player using an item.</param>
/// <param name="itemToUse">Item to use.</param>
public void UseItem(IPlayerEntity player, Item itemToUse)
{
this._logger.LogTrace($"{player.Object.Name} want to use {itemToUse.Data.Name}.");
if (player.Inventory.ItemHasCoolTime(itemToUse) && !player.Inventory.CanUseItemWithCoolTime(itemToUse))
{
this._logger.LogDebug($"Player '{player.Object.Name}' cannot use item {itemToUse.Data.Name}: CoolTime.");
return;
}
switch (itemToUse.Data.ItemKind2)
{
case ItemKind2.REFRESHER:
case ItemKind2.POTION:
case ItemKind2.FOOD:
this.UseFoodItem(player, itemToUse);
break;
case ItemKind2.BLINKWING:
this.UseBlinkwingItem(player, itemToUse);
break;
default:
this._logger.LogDebug($"Item usage for {itemToUse.Data.ItemKind2} is not implemented.");
WorldPacketFactory.SendSnoop(player, $"Item usage for {itemToUse.Data.ItemKind2} is not implemented.");
break;
}
}
private void GetMailGold(IPlayerEntity player, QueryGetMailGoldEventArgs e)
{
var database = DependencyContainer.Instance.Resolve <IDatabase>();
var mail = database.Mails.Get(x => x.Id == e.MailId && x.ReceiverId == player.PlayerData.Id);
if (mail is null)
{
return;
}
if (mail.HasReceivedGold)
{
return;
}
checked
{
try
{
player.PlayerData.Gold += (int)mail.Gold;
mail.HasReceivedGold = true;
}
catch (OverflowException)
{
Logger.LogError($"{player.Object.Name} caused an OverflowException by taking {mail.Gold} out of mail {mail.Id}.");
return;
}
}
database.Complete();
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.GOLD, player.PlayerData.Gold);
WorldPacketFactory.SendRemoveMail(player, mail, RemovedFromMail.Gold);
}
/// <summary>
/// Update monster moves.
/// </summary>
/// <param name="monster"></param>
private void ProcessMonsterMovements(IMonsterEntity monster)
{
if (monster.Timers.NextMoveTime <= Time.TimeInSeconds() &&
monster.Object.MovingFlags.HasFlag(ObjectState.OBJSTA_STAND))
{
this.MoveToPosition(monster, monster.Region.GetRandomPosition());
}
else if (monster.Object.MovingFlags.HasFlag(ObjectState.OBJSTA_STAND))
{
if (monster.Moves.ReturningToOriginalPosition)
{
monster.Health.Hp = monster.Data.AddHp;
WorldPacketFactory.SendUpdateAttributes(monster, DefineAttributes.HP, monster.Health.Hp);
monster.Moves.ReturningToOriginalPosition = false;
}
else
{
if (monster.Moves.SpeedFactor >= 2f)
{
monster.Moves.SpeedFactor = 1f;
WorldPacketFactory.SendSpeedFactor(monster, monster.Moves.SpeedFactor);
}
}
}
}
public static void CreateItem(IPlayerEntity player, string[] parameters)
{
Logger.Debug("{0} want to create an item", player.Object.Name);
if (parameters.Length <= 0)
{
Logger.Error("Chat: /createitem command must have at least one parameter.");
return;
}
if (!player.Inventory.HasAvailableSlots())
{
WorldPacketFactory.SendDefinedText(player, DefineText.TID_GAME_LACKSPACE);
return;
}
var quantity = 1;
if (!int.TryParse(parameters[0], out int itemId))
{
ItemData itemData = GameResources.Instance.Items[parameters[0]];
itemId = itemData?.Id ?? -1;
}
if (parameters.Length >= 2)
{
int.TryParse(parameters[1], out quantity);
}
var createItemEvent = new InventoryCreateItemEventArgs(itemId, quantity, player.PlayerData.Id);
player.NotifySystem <InventorySystem>(createItemEvent);
}
private void GetMailItem(IPlayerEntity player, QueryGetMailItemEventArgs e)
{
var database = DependencyContainer.Instance.Resolve <IDatabase>();
var mail = database.Mails.Get(x => x.Id == e.MailId && x.ReceiverId == player.PlayerData.Id);
if (mail is null)
{
return;
}
if (mail.HasReceivedItem)
{
return;
}
if (!player.Inventory.HasAvailableSlots())
{
WorldPacketFactory.SendDefinedText(player, DefineText.TID_GAME_LACKSPACE);
return;
}
mail.HasReceivedItem = true;
int availableSlot = player.Inventory.GetAvailableSlot();
player.Inventory.Items[availableSlot] = new Item(mail.Item);
database.Complete();
WorldPacketFactory.SendRemoveMail(player, mail, RemovedFromMail.Item);
}
private void EquipItem(IPlayerEntity player, Item item)
{
this.Logger.LogTrace($"{player.Object.Name} want to equip {item.Data.Name}.");
if (!this._itemUsage.IsItemEquipable(player, item))
{
this.Logger.LogTrace($"{player.Object.Name} can not equip {item.Data.Name}.");
return;
}
int sourceSlot = item.Slot;
int equipedItemSlot = item.Data.Parts + EquipOffset;
Item equipedItem = player.Inventory[equipedItemSlot];
if (equipedItem != null && equipedItem.Slot != -1)
{
this.UnequipItem(player, equipedItem);
}
// Move item
item.Slot = equipedItemSlot;
player.Inventory.Items.Swap(sourceSlot, equipedItemSlot);
WorldPacketFactory.SendItemEquip(player, item, item.Data.Parts, true);
}
public static void OnPlayerBehavior(WorldClient client, INetPacketStream packet)
{
var playerBehaviorPacket = new PlayerBehaviorPacket(packet);
if (client.Player.Health.IsDead)
{
Logger.LogError($"Player {client.Player.Object.Name} is dead, he cannot move with keyboard.");
return;
}
// TODO: check if player is flying
client.Player.Object.Position = playerBehaviorPacket.BeginPosition + playerBehaviorPacket.DestinationPosition;
client.Player.Object.Angle = playerBehaviorPacket.Angle;
client.Player.Object.MovingFlags = (ObjectState)playerBehaviorPacket.State;
client.Player.Object.MotionFlags = (StateFlags)playerBehaviorPacket.StateFlag;
client.Player.Moves.IsMovingWithKeyboard = client.Player.Object.MovingFlags.HasFlag(ObjectState.OBJSTA_FMOVE) ||
client.Player.Object.MovingFlags.HasFlag(ObjectState.OBJSTA_BMOVE);
client.Player.Moves.DestinationPosition = playerBehaviorPacket.BeginPosition + playerBehaviorPacket.DestinationPosition;
WorldPacketFactory.SendMoverBehavior(client.Player,
playerBehaviorPacket.BeginPosition,
playerBehaviorPacket.DestinationPosition,
client.Player.Object.Angle,
(uint)client.Player.Object.MovingFlags,
(uint)client.Player.Object.MotionFlags,
playerBehaviorPacket.Motion,
playerBehaviorPacket.MotionEx,
playerBehaviorPacket.Loop,
playerBehaviorPacket.MotionOption,
playerBehaviorPacket.TickCount);
}
private static void TradeConfirm(IPlayerEntity player, TradeConfirmEventArgs e)
{
Logger.Debug("Trade confirm");
if (IsNotTrading(player))
{
throw new RhisisSystemException($"No trade target {player.Object.Name}");
}
var target = GetEntityFromContextOf(player, player.Trade.TargetId);
if (IsNotTrading(target))
{
CancelTrade(player);
throw new RhisisSystemException($"Target is not trading {target.Object.Name}");
}
if (IsNotTradeState(player, TradeComponent.TradeState.Ok))
{
return;
}
if (IsTradeState(target, TradeComponent.TradeState.Ok))
{
player.Trade.State = TradeComponent.TradeState.Confirm;
WorldPacketFactory.SendTradeLastConfirmOk(player, player.Id);
WorldPacketFactory.SendTradeLastConfirmOk(target, player.Id);
}
else if (IsTradeState(target, TradeComponent.TradeState.Confirm))
{
FinalizeTrade(player, target);
}
}
public void Dispatch(ISession session, IPacket packet)
{
BinaryReader reader = packet.CreateReader();
int guildId = reader.ReadInt32();
var guild = new Guild
{
Id = guildId,
Name = "guild"
};
IPacketBuilder responce = WorldPacketFactory.Build(
WMSG.SMSG_GUILD_QUERY_RESPONSE,
writer =>
{
writer.Write(guild.Id);
writer.WriteCString(guild.Name);
foreach (GuildRank rank in guild.Ranks)
{
writer.WriteCString(rank.Name);
}
for (int i = 0; i < 10 - guild.Ranks.Count; i++)
{
writer.WriteCString(string.Empty);
}
writer.Write(guild.Tabard.EmblemStyle);
writer.Write(guild.Tabard.EmblemColor);
writer.Write(guild.Tabard.BorderStyle);
writer.Write(guild.Tabard.BorderColor);
writer.Write(guild.Tabard.BackgroundColor);
writer.Write(0); // NEW 3.0.2
});
session.Send(responce);
}
/// <summary>
/// Start a new trade / accepting the trade
/// </summary>
/// <param name="player"></param>
/// <param name="e"></param>
private static void Trade(IPlayerEntity player, TradeBeginEventArgs e)
{
if (e.TargetId == player.Id)
{
throw new RhisisSystemException($"Can't start a Trade with ourselve ({player.Object.Name})");
}
if (IsTrading(player))
{
throw new RhisisSystemException($"Can't start a Trade when one is already in progress ({player.Object.Name})");
}
var target = GetEntityFromContextOf(player, e.TargetId);
if (IsTrading(target))
{
throw new RhisisSystemException($"Can't start a Trade when one is already in progress ({target.Object.Name})");
}
player.Trade.TargetId = target.Id;
target.Trade.TargetId = player.Id;
WorldPacketFactory.SendTrade(player, target, player.Id);
WorldPacketFactory.SendTrade(target, player, player.Id);
}
/// <summary>
/// Put gold to the current trade
/// </summary>
/// <param name="player"></param>
/// <param name="e"></param>
private static void PutGold(IPlayerEntity player, TradePutGoldEventArgs e)
{
Logger.Debug("PutGold");
if (IsNotTrading(player))
{
throw new RhisisSystemException($"No trade target {player.Object.Name}");
}
var target = GetEntityFromContextOf(player, player.Trade.TargetId);
if (IsNotTrading(target))
{
CancelTrade(player);
throw new RhisisSystemException($"Target is not trading {target.Object.Name}");
}
if (IsNotTradeState(player, TradeComponent.TradeState.Item) ||
IsNotTradeState(target, TradeComponent.TradeState.Item))
{
throw new RhisisSystemException($"Not the right trade state {player.Object.Name}");
}
player.PlayerData.Gold -= e.Gold;
player.Trade.Gold += e.Gold;
WorldPacketFactory.SendTradePutGold(player, player.Id, player.Trade.Gold);
WorldPacketFactory.SendTradePutGold(target, player.Id, player.Trade.Gold);
}
/// <summary>
/// Applies death penality if enabled.
/// </summary>
/// <param name="player">Death player entity.</param>
private void ProcessDeathPenality(IPlayerEntity player)
{
if (this._worldConfiguration.Death.DeathPenalityEnabled)
{
decimal expLossPercent = GameResources.Instance.Penalities.GetDecExpPenality(player.Object.Level);
if (expLossPercent <= 0)
{
return;
}
player.PlayerData.Experience -= player.PlayerData.Experience * (long)(expLossPercent / 100m);
player.PlayerData.DeathLevel = player.Object.Level;
if (player.PlayerData.Experience < 0)
{
if (GameResources.Instance.Penalities.GetLevelDownPenality(player.Object.Level))
{
CharacterExpTableData previousLevelExp = GameResources.Instance.ExpTables.GetCharacterExp(player.Object.Level - 1);
player.Object.Level--;
player.PlayerData.Experience = previousLevelExp.Exp + player.PlayerData.Experience;
}
else
{
player.PlayerData.Experience = 0;
}
}
WorldPacketFactory.SendPlayerExperience(player);
}
}
public static void OnMeleeAttack(WorldClient client, INetPacketStream packet)
{
var meleePacket = new MeleeAttackPacket(packet);
var target = client.Player.Object.CurrentLayer.FindEntity <IMonsterEntity>(meleePacket.ObjectId);
if (target == null)
{
Logger.LogError($"Cannot find target with object id {meleePacket.ObjectId}");
return;
}
Item weaponItem = client.Player.Inventory.GetItem(x => x.Slot == InventorySystem.RightWeaponSlot) ?? InventorySystem.Hand;
if (weaponItem != null && weaponItem.Data?.AttackSpeed != meleePacket.WeaponAttackSpeed)
{
Logger.LogCritical($"Player {client.Player.Object.Name} has changed his weapon speed.");
return;
}
if (!target.Follow.IsFollowing && target.Type == WorldEntityType.Monster)
{
if (target.Moves.SpeedFactor != 2f)
{
target.Moves.SpeedFactor = 2f;
WorldPacketFactory.SendSpeedFactor(target, target.Moves.SpeedFactor);
}
target.NotifySystem <FollowSystem>(new FollowEventArgs(client.Player.Id, 1f));
}
client.Player.NotifySystem <BattleSystem>(new MeleeAttackEventArgs(meleePacket.AttackMessage, target, meleePacket.WeaponAttackSpeed));
}
/// <summary>
/// Sells an item to a NPC shop.
/// </summary>
/// <param name="player">Player entity</param>
/// <param name="e"></param>
private void SellItem(IPlayerEntity player, NpcShopSellEventArgs e)
{
Item itemToSell = player.Inventory.GetItem(e.ItemUniqueId);
if (itemToSell?.Data == null)
{
throw new InvalidOperationException($"ShopSystem: Cannot find item with unique id: {e.ItemUniqueId}");
}
if (e.Quantity > itemToSell.Data.PackMax)
{
throw new InvalidOperationException($"ShopSystem: Cannot sell more items than the pack max value. {e.Quantity} > {itemToSell.Data.PackMax}");
}
// TODO: make more checks:
// is a quest item
// is sealed to character
// ect...
int sellPrice = itemToSell.Data.Cost / 4;
Logger.Debug("Selling item: '{0}' for {1}", itemToSell.Data.Name, sellPrice);
player.PlayerData.Gold += sellPrice * e.Quantity;
itemToSell.Quantity -= e.Quantity;
WorldPacketFactory.SendItemUpdate(player, UpdateItemType.UI_NUM, itemToSell.UniqueId, itemToSell.Quantity);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.GOLD, player.PlayerData.Gold);
if (itemToSell.Quantity <= 0)
{
itemToSell.Reset();
}
}
private void OnChangeFace(IPlayerEntity player, ChangeFaceEventArgs e)
{
var worldConfiguration = DependencyContainer.Instance.Resolve <WorldConfiguration>();
if (!e.UseCoupon)
{
if (player.PlayerData.Gold < worldConfiguration.Customization.ChangeFaceCost)
{
WorldPacketFactory.SendDefinedText(player, DefineText.TID_GAME_LACKMONEY);
}
else
{
player.PlayerData.Gold -= (int)worldConfiguration.Customization.ChangeFaceCost;
player.VisualAppearance.FaceId = (int)e.FaceId;
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.GOLD, player.PlayerData.Gold);
WorldPacketFactory.SendChangeFace(player, e.FaceId);
}
}
else
{
var couponItem = player.Inventory.GetItemById(DefineItem.II_SYS_SYS_SCR_FACEOFFFREE);
if (couponItem == null)
{
WorldPacketFactory.SendDefinedText(player, DefineText.TID_GAME_WARNNING_COUPON);
return;
}
player.Inventory.RemoveItems(couponItem.Data.Id);
WorldPacketFactory.SendItemUpdate(player, UpdateItemType.UI_NUM, couponItem.UniqueId, couponItem.Quantity);
WorldPacketFactory.SendChangeFace(player, e.FaceId);
}
}
/// <summary>
/// Create a new item.
/// </summary>
/// <param name="player">Player entity</param>
/// <param name="e"></param>
private void CreateItem(IPlayerEntity player, InventoryCreateItemEventArgs e)
{
ItemData itemData = e.ItemData;
if (itemData.IsStackable)
{
// TODO: stackable items
}
else
{
for (var i = 0; i < e.Quantity; i++)
{
int availableSlot = player.Inventory.GetAvailableSlot();
if (availableSlot < 0)
{
WorldPacketFactory.SendDefinedText(player, DefineText.TID_GAME_LACKSPACE);
break;
}
Logger.Debug("Available slot: {0}", availableSlot);
var newItem = new Item(e.ItemId, 1, e.CreatorId)
{
Slot = availableSlot,
UniqueId = availableSlot,
};
player.Inventory.Items[availableSlot] = newItem;
WorldPacketFactory.SendItemCreation(player, newItem);
}
}
}
private void OnPartyMemberRequest(IPlayerEntity player, PartyMemberRequestEventArgs e)
{
var worldServer = DependencyContainer.Instance.Resolve <IWorldServer>();
if (player.PlayerData.Id != e.PlayerId)
{
return;
}
var member = worldServer.GetPlayerEntityByCharacterId(e.MemberId);
if (member == null)
{
WorldPacketFactory.SendAddPartyRequestCancel(player, e.MemberId, PartyRequestCancelMode.OtherServer);
return;
}
// TODO: Check if in GW, Duel or other stuff that might disturb the player.
if (member.Party.IsInParty)
{
WorldPacketFactory.SendAddPartyRequestCancel(player, e.MemberId, PartyRequestCancelMode.OtherParty);
return;
}
// Send Request to other player
WorldPacketFactory.SendAddPartyRequest(player, member, e.Troup);
}
public void Dispatch(ISession session, IPacket packet)
{
BinaryReader reader = packet.CreateReader();
byte castCount = reader.ReadByte();
uint spellId = reader.ReadUInt32();
byte unklags = reader.ReadByte();
IPacket pkt = WorldPacketFactory.Create(WMSG.SMSG_SPELL_START);
BinaryWriter writer = pkt.CreateWriter();
writer.WritePackGuid(session.Player.Guid);
writer.WritePackGuid(session.Player.Guid);
writer.Write(castCount);
writer.Write(spellId);
writer.Write(0); //cast flags
writer.Write(0); //ticks count
writer.Write(0); //targetflags
session.Send(pkt);
Thread.Sleep(5000);
pkt = WorldPacketFactory.Create(WMSG.SMSG_SPELL_GO);
writer = pkt.CreateWriter();
writer.WritePackGuid(session.Player.Guid);
writer.WritePackGuid(session.Player.Guid);
writer.Write(castCount);
writer.Write(spellId);
writer.Write(0); //cast flags
writer.Write(0); //ticks count
writer.Write((byte)1); //hit count
writer.Write(session.Player.Guid);
writer.Write((byte)0); //miss count
writer.Write(0); // targetflags
session.Send(pkt);
}
/// <summary>
/// Equips an item.
/// </summary>
/// <param name="player"></param>
/// <param name="e"></param>
private void EquipItem(IPlayerEntity player, InventoryEquipEventArgs e)
{
var uniqueId = e.UniqueId;
var part = e.Part;
Logger.Debug("UniqueId: {0} | Part: {1}", uniqueId, part);
Item item = player.Inventory.GetItem(uniqueId);
if (item == null)
{
return;
}
bool equip = part == -1;
Logger.Debug("Equip item: {0}", equip.ToString());
if (equip)
{
Logger.Debug("Item: {0}", item.ToString());
// TODO: check if the player fits the item requirements
if (item.Data.ItemKind1 == ItemKind1.ARMOR && item.Data.ItemSex != player.VisualAppearance.Gender)
{
Logger.Debug("Wrong sex for armor");
// TODO: Send invalid sex error
return;
}
if (player.Object.Level < item.Data.LimitLevel)
{
Logger.Debug("Player level to low");
// TODO: Send low level error
return;
}
// TODO: SPECIAL: double weapon for blades...
int sourceSlot = item.Slot;
int equipedItemSlot = item.Data.Parts + EquipOffset;
Item equipedItem = player.Inventory[equipedItemSlot];
if (equipedItem != null && equipedItem.Slot != -1)
{
this.UnequipItem(player, equipedItem);
}
// Move item
item.Slot = equipedItemSlot;
player.Inventory.Items.Swap(sourceSlot, equipedItemSlot);
WorldPacketFactory.SendItemEquip(player, item, item.Data.Parts, true);
}
else
{
this.UnequipItem(player, item);
}
}
/// <summary>
/// Moves the monster to a position.
/// </summary>
/// <param name="monster"></param>
/// <param name="destPosition"></param>
private void MoveToPosition(IMonsterEntity monster, Vector3 destPosition)
{
monster.Timers.NextMoveTime = Time.TimeInSeconds() + RandomHelper.LongRandom(8, 20);
monster.MovableComponent.DestinationPosition = destPosition.Clone();
monster.Object.Angle = Vector3.AngleBetween(monster.Object.Position, destPosition);
WorldPacketFactory.SendDestinationPosition(monster);
}
/// <summary>
/// Moves the monster to a position.
/// </summary>
/// <param name="monster"></param>
/// <param name="destPosition"></param>
private void MoveToPosition(IMonsterEntity monster, Vector3 destPosition)
{
monster.Object.Angle = Vector3.AngleBetween(monster.Object.Position, destPosition);
monster.Object.MovingFlags = ObjectState.OBJSTA_FMOVE;
monster.Moves.DestinationPosition = destPosition.Clone();
WorldPacketFactory.SendDestinationPosition(monster);
WorldPacketFactory.SendDestinationAngle(monster, false);
}
public static void OnSelectCharacter(WorldClient client, IPacketStream packet)
{
var selectCharacterPacket = new SelectCharacterPacket(packet);
using var database = DependencyContainer.Instance.Resolve <IDatabase>();
var character = database.Charaters.Include(c => c.Items).Where(c => c.Id == selectCharacterPacket.CharacterId).FirstOrDefault();
WorldPacketFactory.SendSelectedCharacter(client, character);
}
public static void OnCheckAvailableName(WorldClient client, IPacketStream packet)
{
var checkNamePacket = new CheckCharacterAvailableNamePacket(packet);
using var database = DependencyContainer.Instance.Resolve <IDatabase>();
DbCharacter character = database.Charaters.Get(c => c.Name == checkNamePacket.CharacterName);
WorldPacketFactory.SendCharacterAvailability(client, character is null);
}
private static IPacket GetUpdateAccountDataCompletePkt(AccountDataType type)
{
IPacket packet = WorldPacketFactory.Create(WMSG.SMSG_UPDATE_ACCOUNT_DATA_COMPLETE);
BinaryWriter writer = packet.CreateWriter();
writer.Write((uint)type);
writer.Write(0);
return(packet);
}
private IPacket GetPowerUpdatePkt(uint value)
{
IPacket packet = WorldPacketFactory.Create(WMSG.SMSG_POWER_UPDATE);
BinaryWriter writer = packet.CreateWriter();
writer.WritePackGuid(Guid);
writer.Write((byte)PowerType);
writer.Write(value);
return(packet);
}
private void GetMails(IPlayerEntity player, QueryMailboxEventArgs e)
{
var database = DependencyContainer.Instance.Resolve <IDatabase>();
var receiver = database.Characters.Get(x => x.Id == player.PlayerData.Id);
if (receiver != null)
{
WorldPacketFactory.SendMailbox(player, receiver.ReceivedMails.Where(x => !x.IsDeleted).ToList());
}
}
public static void OnSnapshotSetDestPosition(WorldClient client, INetPacketStream packet)
{
var setDestPositionPacket = new SetDestPositionPacket(packet);
client.Player.MovableComponent.DestinationPosition = new Vector3(setDestPositionPacket.X, setDestPositionPacket.Y, setDestPositionPacket.Z);
client.Player.Object.Angle = Vector3.AngleBetween(client.Player.Object.Position, client.Player.MovableComponent.DestinationPosition);
client.Player.Follow.Target = null;
WorldPacketFactory.SendDestinationPosition(client.Player);
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!(entity is IPlayerEntity player))
{
this._logger.LogError($"Cannot execute DeathSystem. {entity.Object.Name} is not a player.");
return;
}
IMapRevivalRegion revivalRegion = player.Object.CurrentMap.GetNearRevivalRegion(player.Object.Position);
if (revivalRegion == null)
{
this._logger.LogError($"Cannot find any revival region for map '{player.Object.CurrentMap.Name}'.");
return;
}
decimal recoveryRate = GameResources.Instance.Penalities.GetRevivalPenality(player.Object.Level) / 100;
var jobData = player.PlayerData.JobData;
int strength = player.Attributes[DefineAttributes.STR];
int stamina = player.Attributes[DefineAttributes.STA];
int dexterity = player.Attributes[DefineAttributes.DEX];
int intelligence = player.Attributes[DefineAttributes.INT];
player.Health.Hp = (int)(HealthFormulas.GetMaxOriginHp(player.Object.Level, stamina, jobData.MaxHpFactor) * recoveryRate);
player.Health.Mp = (int)(HealthFormulas.GetMaxOriginMp(player.Object.Level, intelligence, jobData.MaxMpFactor, true) * recoveryRate);
player.Health.Fp = (int)(HealthFormulas.GetMaxOriginFp(player.Object.Level, stamina, dexterity, strength, jobData.MaxFpFactor, true) * recoveryRate);
if (player.Object.MapId != revivalRegion.MapId)
{
IMapInstance revivalMap = this._mapLoader.GetMapById(revivalRegion.MapId);
if (revivalMap == null)
{
this._logger.LogError($"Cannot find revival map with id '{revivalRegion.MapId}'.");
player.Connection.Server.DisconnectClient(player.Connection.Id);
return;
}
revivalRegion = revivalMap.GetRevivalRegion(revivalRegion.Key);
}
var teleportEvent = new TeleportEventArgs(revivalRegion.MapId, revivalRegion.RevivalPosition.X, revivalRegion.RevivalPosition.Z);
player.NotifySystem <TeleportSystem>(teleportEvent);
WorldPacketFactory.SendMotion(player, ObjectMessageType.OBJMSG_ACC_STOP | ObjectMessageType.OBJMSG_STOP_TURN | ObjectMessageType.OBJMSG_STAND);
WorldPacketFactory.SendPlayerRevival(player);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.HP, player.Health.Hp);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.MP, player.Health.Mp);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.FP, player.Health.Fp);
this.ProcessDeathPenality(player);
}
/// <summary>
/// Despawns the other entity for the current entity.
/// </summary>
/// <param name="entity">Current entity</param>
/// <param name="otherEntity">other entity</param>
private static void DespawnOtherEntity(IEntity entity, IEntity otherEntity)
{
var player = entity as IPlayerEntity;
WorldPacketFactory.SendDespawnObjectTo(player, otherEntity);
entity.Object.Entities.Remove(otherEntity);
if (otherEntity.Type != WorldEntityType.Player && otherEntity.Object.Entities.Contains(entity))
{
otherEntity.Object.Entities.Remove(entity);
}
}
public IPacket GetCharEnumPkt()
{
IPacket p = WorldPacketFactory.Create(WMSG.SMSG_CHAR_ENUM);
BinaryWriter w = p.CreateWriter();
w.Write((byte)players.Count);
foreach (Player player in players)
{
w.Write(player.Guid);
w.WriteCString(player.Name);
w.Write((byte)player.Race);
w.Write((byte)player.Classe);
w.Write((byte)player.Gender);
w.Write(player.Skin);
w.Write(player.Face);
w.Write(player.HairStyle);
w.Write(player.HairColor);
w.Write(player.FacialHair);
w.Write((byte)player.Level);
w.Write(player.ZoneId);
w.Write(player.MapId);
w.Write(player.PosX);
w.Write(player.PosY);
w.Write(player.PosZ);
w.Write(player.GuildMember.With(x => x.Guild.Id));
uint flag = 0x00000000;
w.Write(flag);
w.Write((byte)0);
w.Write(player.PetDisplayId);
w.Write(player.PetLevel);
w.Write(player.PetCreatureFamily);
w.Write(0);
for (int i = 0; i < 23; i++)
{
Item item = player.Inventory[i];
if (item != null)
{
w.Write(item.Template.DisplayId);
w.Write((byte)item.Template.InventoryType);
w.Write(0);
}
else
{
w.Write(0);
w.Write((byte)0);
w.Write(0);
}
}
}
return(p);
}
