public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
Models.Items.Item item;
if (player.Inventory.TryGetItem(packet.TargetClientId, out item))
{
if (!item.Discardable)
{
player.SendSystemMessage("NO_PERMISSION_ITEM");
return(true);
}
if ((player.Trade.Partner.Inventory.Count + player.Trade.Items.Count) >= 40)
{
player.SendSystemMessage("TARGET_FULL_INVENTORY");
return(true);
}
player.Trade.Items.Add(item);
item.UpdateClient(player.Trade.Partner, Enums.ItemUpdateAction.Trade);
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (player.Trade.Trading && player.Trade.Partner == null)
{
player.SendSystemMessage("SELF_ALREADY_TRADE");
return(true);
}
else if (player.Trade.Trading)
{
if (!player.Trade.Requesting)
{
packet.Action = Enums.TradeAction.ShowTable;
packet.TargetClientId = player.Trade.Partner.ClientId;
player.ClientSocket.Send(packet);
packet.TargetClientId = player.ClientId;
player.Trade.Partner.ClientSocket.Send(packet);
player.Trade.WindowOpen = true;
player.Trade.Partner.Trade.WindowOpen = true;
}
return(true);
}
Models.Maps.IMapObject obj;
if (player.GetFromScreen(packet.TargetClientId, out obj))
{
var target = obj as Models.Entities.Player;
if (!target.Trade.Trading)
{
player.Trade.Begin(target);
target.Trade.Begin(player);
target.Trade.Requesting = false;
player.Trade.Requesting = true;
packet.TargetClientId = player.ClientId;
target.ClientSocket.Send(packet);
}
else
{
player.SendSystemMessage("TARGET_ALREADY_TRADE");
}
}
else
{
player.ClientSocket.Disconnect(Drivers.Messages.Errors.INVALID_TRADE_TARGET);
}
return(true);
}
public static bool HandleBuy(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
if (player.Inventory.Count == 40)
{
player.SendSystemMessage("INVENTORY_FULL");
return(true);
}
Models.Misc.Shop shop;
if (Collections.ShopCollection.TryGetShop(packet.ClientId, out shop))
{
var npc = shop.Npc;
if (shop.ShopType != Enums.ShopType.Money || npc != null && Tools.RangeTools.ValidDistance(npc.X, npc.Y, player.X, player.Y))
{
uint itemId = packet.Data1;
if (!shop.Items.Contains(itemId))
{
return(false);
}
uint amount = packet.Data2;
int above = (int)((player.Inventory.Count + amount) - 40);
if (above > 0)
{
amount -= (uint)above;
}
if ((player.Inventory.Count + amount) > 40)
{
player.SendSystemMessage("INVENTORY_NO_SPACE");
return(true);
}
switch (shop.ShopType)
{
case Enums.ShopType.Money:
return(HandleBuy(player, itemId, amount, true));
case Enums.ShopType.CPs:
return(HandleBuy(player, itemId, amount, false));
default:
return(true);
}
}
}
return(false);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
uint cps = packet.TargetClientId;
if (cps > player.CPs)
{
player.SendSystemMessage("LOW_CPS_TRADE");
return(true);
}
player.Trade.CPs = cps;
packet.Action = Enums.TradeAction.ShowConquerPoints;
player.Trade.Partner.ClientSocket.Send(packet);
return(true);
}
public static bool HandleSell(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
Models.Misc.Shop shop;
if (Collections.ShopCollection.TryGetShop(packet.ClientId, out shop))
{
var npc = shop.Npc;
if (npc != null && Tools.RangeTools.ValidDistance(npc.X, npc.Y, player.X, player.Y))
{
Models.Items.Item item;
if (player.Inventory.TryGetItem(packet.Data1, out item))
{
if (!item.Discardable)
{
player.SendSystemMessage("NO_PERMISSION_ITEM");
return(true);
}
player.AddActionLog("Sell", item.DbOwnerItem.Id);
uint giveback = (uint)(item.DbOwnerItem.CurrentDura > 0 ? (item.DbItem.Price / 3) : 0);
if (player.Inventory.Remove(item.ClientId))
{
player.Money += giveback;
}
}
}
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
uint money = packet.TargetClientId;
if (money > player.Money)
{
player.SendSystemMessage("LOW_MONEY_TRADE");
return(true);
}
player.Trade.Money = money;
packet.Action = Enums.TradeAction.ShowMoney;
player.Trade.Partner.ClientSocket.Send(packet);
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Items.WarehousePacket packet)
{
if (player.Guild != null && player.Guild.InHouse(player))
{
if (player.Inventory.Count >= 40)
{
player.SendSystemMessage("WAREHOUSE_FULL");
return(true);
}
var item = player.Guild.Warehouse.Pop(packet.ClientId);
if (item != null)
{
player.Inventory.Add(item);
}
player.ClientSocket.Send(packet);
}
else
{
Collections.Warehouse warehouse;
if (player.Warehouses.TryGetWarehouse(player.CurrentNpc.ClientId, out warehouse))
{
if (player.Inventory.Count >= 20)
{
player.SendSystemMessage("WAREHOUSE_FULL");
return(true);
}
var item = warehouse.Pop(packet.ClientId);
if (item != null)
{
player.Inventory.Add(item);
}
player.ClientSocket.Send(packet);
}
}
return(true);
}
public static bool HandleRepair(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
Models.Items.Item repairItem;
if (player.Inventory.TryGetItem(packet.ClientId, out repairItem))
{
if (repairItem.DbOwnerItem.CurrentDura <= 0)
{
int meteorAmount;
if (!player.Inventory.ContainsById(1088001, out meteorAmount) || meteorAmount < 5)
{
player.SendSystemMessage("REPAIR_NOT_ENOUGH_METEORS");
return(true);
}
if (!player.Inventory.RemoveByCount(1088001, 5))
{
player.SendSystemMessage("REPAIR_NOT_ENOUGH_METEORS");
return(true);
}
}
else
{
uint repairPrice = repairItem.RepairPrice;
if (player.Money < repairPrice)
{
player.SendSystemMessage("REPAIR_NOT_ENOUGH_MONEY");
return(true);
}
player.Money -= repairPrice;
}
player.AddActionLog("Repair", repairItem.DbOwnerItem.Id);
repairItem.DbOwnerItem.CurrentDura = repairItem.DbOwnerItem.MaxDura;
repairItem.UpdateDatabase();
repairItem.UpdateClient(player, Enums.ItemUpdateAction.Update);
}
return(true);
}
public static bool HandleCPs(Models.Entities.Player player, Models.Packets.Guilds.GuildPacket packet)
{
if (player.Guild != null)
{
if (!player.Guild.DonateCPs(player, packet.Data))
{
player.SendSystemMessage("LOW_CPS_DONATE_GUILD");
}
}
return(true);
}
/// <summary>
/// Verifies that the composition can be done.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="packet">The packet.</param>
/// <param name="mainItem">The main item.</param>
/// <param name="minorItem">The minor item.</param>
/// <returns>True if the composition can be done, false otherwise.</returns>
private static bool VerifyComposition(Models.Entities.Player player, Models.Packets.Items.CompositionPacket packet,
out Models.Items.Item mainItem, out Models.Items.Item minorItem)
{
mainItem = null;
minorItem = null;
if (!player.Alive)
{
return(false);
}
if (!player.Inventory.TryGetItem(packet.MainItemClientId, out mainItem))
{
player.SendSystemMessage("COMPOSITION_ITEM_NOT_FOUND");
return(false);
}
if (!player.Inventory.TryGetItem(packet.MinorItemClientId, out minorItem))
{
player.SendSystemMessage("COMPOSITION_ITEM_NOT_FOUND");
return(false);
}
if (mainItem.IsGarment || mainItem.IsArrow || mainItem.IsBottle || mainItem.IsMountArmor || mainItem.IsMisc)
{
player.SendSystemMessage("COMPOSITION_ITEM_INVALID");
return(false);
}
if (mainItem.DbOwnerItem.CurrentDura < mainItem.DbOwnerItem.MaxDura)
{
player.SendSystemMessage("COMPOSITION_ITEM_LOW_DURA");
return(false);
}
if (mainItem.DbOwnerItem.Plus >= Data.Constants.GameMode.MaxPlus)
{
player.SendSystemMessage("COMPOSITION_ITEM_MAX_PLUS");
return(false);
}
if (minorItem.DbOwnerItem.Plus == 0)
{
player.SendSystemMessage("COMPOSITION_MINOR_ITEM_NO_PLUS");
return(false);
}
if (minorItem.DbOwnerItem.Plus < mainItem.DbOwnerItem.Plus)
{
player.SendSystemMessage("COMPOSITION_MINOR_ITEM_LOW_PLUS");
return(false);
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Items.WarehousePacket packet)
{
if (player.Guild != null && player.Guild.InHouse(player))
{
if (player.Guild.Warehouse.Count >= 20)
{
player.SendSystemMessage("WAREHOUSE_FULL");
return(true);
}
var item = player.Inventory.Pop(packet.ClientId);
if (item != null)
{
player.AddActionLog("AddGuildWarehouseItem", item.DbItem.Id);
player.Guild.Warehouse.Add(item, player);
}
}
else
{
Collections.Warehouse warehouse;
if (player.Warehouses.TryGetWarehouse(player.CurrentNpc.ClientId, out warehouse))
{
if (warehouse.Count >= 20)
{
player.SendSystemMessage("WAREHOUSE_FULL");
return(true);
}
var item = player.Inventory.Pop(packet.ClientId);
if (item != null)
{
player.AddActionLog("AddWarehouseItem", item.DbItem.Id + " :" + warehouse.Id);
warehouse.Add(item);
}
}
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
if (!player.Alive)
{
return(true);
}
Models.Items.Item upgradeItem;
Models.Items.Item meteor;
if (!player.Inventory.TryGetItem(packet.ClientId, out upgradeItem) ||
!player.Inventory.TryGetItem(packet.Data1, out meteor) ||
(meteor.DbItem.Id != 1088001 && meteor.DbItem.Id != 1088002))
{
player.SendSystemMessage("UPLEVEL_ITEM_NOT_FOUND_OR_NO_METEORS");
return(true);
}
if (upgradeItem.DbOwnerItem.CurrentDura < upgradeItem.DbOwnerItem.MaxDura)
{
player.SendSystemMessage("UPLEVEL_ITEM_LOW_DURA");
return(true);
}
if (upgradeItem.IsGarment || upgradeItem.IsArrow || upgradeItem.IsBottle || upgradeItem.IsMountArmor || upgradeItem.IsMisc)
{
player.SendSystemMessage("UPLEVEL_ITEM_INVALID");
return(true);
}
if (upgradeItem.DbItem.Level >= 120)
{
player.SendSystemMessage("UPLEVEL_ITEM_MAX_LEVEL");
return(true);
}
if (player.Inventory.Remove(packet.Data1))
{
int extraChance = Math.Max(0, (80 - upgradeItem.DbItem.Level));
int chance = Math.Min(90, Data.Constants.Chances.UpgradeLevelChance + extraChance);
player.AddActionLog("ItemUpLevel", upgradeItem.DbOwnerItem.Id);
if (upgradeItem.UpgradeLevel(player) && Tools.CalculationTools.ChanceSuccess(chance))
{
upgradeItem.UpgradeSockets(player);
player.SendSystemMessage("UPLEVEL_SUCCESS");
}
else
{
player.SendSystemMessage("UPLEVEL_FAIL");
}
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
if (!player.Alive)
{
return(true);
}
Models.Items.Item upgradeItem;
Models.Items.Item dragonBall;
if (!player.Inventory.TryGetItem(packet.ClientId, out upgradeItem) ||
!player.Inventory.TryGetItem(packet.Data1, out dragonBall) ||
dragonBall.DbItem.Id != 1088000)
{
player.SendSystemMessage("IMPROVE_ITEM_NOT_FOUND_OR_NO_DRAGONBALLS");
return(true);
}
if (upgradeItem.DbOwnerItem.CurrentDura < upgradeItem.DbOwnerItem.MaxDura)
{
player.SendSystemMessage("IMPROVE_ITEM_LOW_DURA");
return(true);
}
if (upgradeItem.IsGarment || upgradeItem.IsArrow || upgradeItem.IsBottle || upgradeItem.IsMountArmor || upgradeItem.IsMisc)
{
player.SendSystemMessage("IMPROVE_ITEM_INVALID");
return(true);
}
if (upgradeItem.Quality == Enums.ItemQuality.Super)
{
player.SendSystemMessage("IMPROVE_ITEM_IS_SUPER");
return(true);
}
int extraChance = Math.Max(0, (80 - ((int)upgradeItem.Quality) * 10));
int chance = Math.Min(90, Data.Constants.Chances.UpgradeQualityChance + extraChance);
player.AddActionLog("Improve", upgradeItem.DbOwnerItem.Id);
if (player.Inventory.Remove(packet.Data1) && Tools.CalculationTools.ChanceSuccess(chance))
{
upgradeItem.UpgradeQuality(player);
upgradeItem.UpgradeSockets(player);
player.SendSystemMessage("IMPROVE_SUCCESS");
}
else
{
player.SendSystemMessage("IMPROVE_FAIL");
}
return(true);
}
public static bool HandlePacket(Models.Entities.Player player, Models.Packets.Items.GroundItemPacket packet)
{
if (packet.Action == Enums.GroundItemAction.Pickup && player.Map != null)
{
Models.Maps.IMapObject mapObject;
if (player.GetFromScreen(packet.ClientId, out mapObject))
{
var item = mapObject as Models.Items.Item;
if (item != null && Tools.RangeTools.GetDistanceU(player.X, player.Y, item.X, item.Y) < 2)
{
if (!item.PlayerDrop && DateTime.UtcNow < item.DropTime.AddMilliseconds(Data.Constants.Time.DropTimeShare) &&
item.DropClientId != player.ClientId)
{
player.SendSystemMessage("NOT_OWNER_ITEM");
}
else
{
Task.Run(async() => await item
.ResetLocationAsync(true, () =>
{
if (item.DropMoney > 0)
{
player.AddActionLog("PickUpMoney", item.DropMoney);
player.Money += item.DropMoney;
}
else
{
player.AddActionLog("PickUpItem", item.DbItem.Id);
player.Inventory.Add(item);
}
}, (e) =>
{
player.ClientSocket.LastException = e;
player.ClientSocket.Disconnect(Drivers.Messages.Errors.FATAL_ERROR_TITLE);
}));
}
}
}
return(true);
}
return(false);
}
public static bool HandleRepairAll(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
var repairItems = player.Equipments.GetAll();
uint repairPrice = 0;
// Gets the price for the repair ...
foreach (var item in repairItems)
{
if (item.DbOwnerItem.CurrentDura > 0)
{
repairPrice += item.RepairPrice;
}
}
if (player.Money < repairPrice)
{
// Necessary, because the client automatically sets the durability to max durability without server-side validation.
foreach (var item in repairItems)
{
item.UpdateClient(player, Enums.ItemUpdateAction.Update);
}
player.SendSystemMessage("REPAIR_ALL_NOT_ENOUGH_MONEY");
return(true);
}
player.AddActionLog("RepairAll");
player.Money -= repairPrice;
foreach (var repairItem in repairItems)
{
if (repairItem.DbOwnerItem.CurrentDura >= 0)
{
repairItem.DbOwnerItem.CurrentDura = repairItem.DbOwnerItem.MaxDura;
repairItem.UpdateDatabase();
}
repairItem.UpdateClient(player, Enums.ItemUpdateAction.Update);
}
return(true);
}
public static bool GetCustomPlayerData(Models.Entities.Player player, Models.Packets.Client.DataExchangePacket packet)
{
#region Basic stats
// To update it client side ...
player.BoundCPs = player.BoundCPs;
player.ValidateLoginMap();
player.UpdateStats();
player.Stamina = Data.Constants.GameMode.StartStamina;
#endregion
#region Status Flags
if (!string.IsNullOrWhiteSpace(player.DbPlayer.StatusFlag))
{
player.StaticStatusFlag = player.DbPlayer.StatusFlag.ToEnum <Enums.StatusFlag>();
}
// Idk why, but for some reason you can't update the client any other way with the pk points and status flag ...
var pkp = player.PKPoints;
player.PKPoints = 0;
player.PKPoints = pkp;
#endregion
#region Messages
if (Collections.BroadcastQueue.LastMessage != null)
{
player.ClientSocket.Send(Collections.BroadcastQueue.LastMessage);
}
foreach (var dbWhisper in Database.Dal.WhisperCache.GetAllByRecipent(player.Name, Drivers.Settings.WorldSettings.Server))
{
player.ClientSocket.Send(
Controllers.Packets.Message.MessageController.CreateWhisper(string.Concat("[Sent offline]", dbWhisper.Message), dbWhisper.From, dbWhisper.To, dbWhisper.Mesh, player.Mesh)
);
dbWhisper.Delete();
}
#endregion
#region Houses
var houses = Database.Dal.PlayerHouses.GetAll(player.DbPlayer.Id);
if (houses.Count > 0)
{
bool anyRent = false;
foreach (var dbPlayerHouse in houses)
{
if (!anyRent && dbPlayerHouse.IsLeasing && dbPlayerHouse.NextRentDate.HasValue &&
DateTime.UtcNow >= dbPlayerHouse.NextRentDate.Value)
{
anyRent = true;
}
var playerHouse = new Models.Maps.PlayerHouse(player, dbPlayerHouse);
player.Houses.Add(playerHouse);
if (dbPlayerHouse.Warehouse)
{
player.Warehouses.CreateWarehouse((uint)(dbPlayerHouse.MapId + 100000));
playerHouse.CreateWarehouse();
}
}
if (anyRent)
{
player.SendSystemMessage("RENT_DUE");
}
}
#endregion
#region Warehouse
foreach (var dbOwnerItem in Database.Dal.Warehouses.GetWarehouseItems(player.DbPlayer.Id))
{
var item = Collections.ItemCollection.CreateItemById((uint)dbOwnerItem.ItemId);
item.DbOwnerItem = dbOwnerItem;
if (!string.IsNullOrWhiteSpace(dbOwnerItem.Color))
{
item.Color = dbOwnerItem.Color.ToEnum <Enums.ItemColor>();
}
item.Gem1 = dbOwnerItem.Gem1.ToEnum <Enums.Gem>();
item.Gem2 = dbOwnerItem.Gem2.ToEnum <Enums.Gem>();
Collections.Warehouse warehouse;
if (player.Warehouses.TryGetWarehouse(dbOwnerItem.LocationId.Value, out warehouse))
{
if (!warehouse.Add(item, true))
{
player.ClientSocket.Disconnect(Drivers.Messages.Errors.FAILED_TO_LOAD_WAREHOUSE);
return(false);
}
}
}
#endregion
#region Nobility
Models.Nobility.NobilityDonation nobility;
if (Collections.NobilityBoard.TryGetNobility(player.DbPlayer.Id, out nobility))
{
nobility.Player = player;
player.Nobility = nobility;
}
player.UpdateClientNobility();
#endregion
#region VIP
byte vipLevel = 0;
if (player.DbPlayer.DonationPoints >= 6)
{
vipLevel = 6;
}
else if (player.DbPlayer.DonationPoints > 0)
{
vipLevel = (byte)player.DbPlayer.DonationPoints;
}
player.VIPLevel = vipLevel;
#endregion
#region Arena
Models.Arena.ArenaInfo arenaInfo;
if (!Collections.ArenaQualifierCollection.TryGetArenaInfo(player.DbPlayer.Id, out arenaInfo))
{
arenaInfo = new Models.Arena.ArenaInfo(null)
{
Player = player
};
if (!Collections.ArenaQualifierCollection.TryAddArenaInfo(player.DbPlayer.Id, arenaInfo))
{
player.ClientSocket.Disconnect(Drivers.Messages.Errors.FAILED_TO_INITIALIZE_ARENA_INFO);
}
}
else
{
arenaInfo.Player = player;
}
player.ArenaInfo = arenaInfo;
#endregion
// TODO: Load subclass
// TODO: Load heaven blessing
#region Merchant
player.UpdateClient(Enums.UpdateClientType.Merchant, 255UL);
#endregion
Server.FinishLogin.Handle(player);
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Trade.TradePacket packet)
{
if (!player.Trade.Trading)
{
return(true);
}
if (!player.Trade.WindowOpen)
{
return(true);
}
if (!player.Trade.Accepted && !player.Trade.PartnerAccepted)
{
player.Trade.Accepted = true;
player.Trade.Partner.Trade.Accepted = true;
packet.TargetClientId = player.ClientId;
player.Trade.Partner.ClientSocket.Send(packet);
}
else if (player.Trade.Accepted && player.Trade.Partner.Trade.Accepted)
{
bool tradeSuccess = true;
foreach (var item in player.Trade.Items)
{
if (!player.Inventory.Contains(item.ClientId))
{
tradeSuccess = false;
}
}
foreach (var item in player.Trade.PartnerItems)
{
if (!player.Trade.Partner.Inventory.Contains(item.ClientId))
{
tradeSuccess = false;
}
}
if (player.Money < player.Trade.Money)
{
tradeSuccess = false;
}
if (player.Trade.Partner.Money < player.Trade.PartnerMoney)
{
tradeSuccess = false;
}
if (player.CPs < player.Trade.CPs)
{
tradeSuccess = false;
}
if (player.Trade.Partner.CPs < player.Trade.PartnerCPs)
{
tradeSuccess = false;
}
if (tradeSuccess)
{
foreach (var item in player.Trade.Items)
{
player.AddActionLog("TradeItem", string.Format("{0} -> {1} : {2}", player.DbPlayer.Id, player.Trade.Partner.DbPlayer.Id, item.DbItem.Id));
var removedItem = player.Inventory.Pop(item.ClientId);
if (removedItem != null)
{
player.Trade.Partner.Inventory.Add(removedItem);
}
}
foreach (var item in player.Trade.PartnerItems)
{
player.AddActionLog("TradeItem", string.Format("{0} -> {1} : {2}", player.Trade.Partner.DbPlayer.Id, player.DbPlayer.Id, item.DbItem.Id));
var removedItem = player.Trade.Partner.Inventory.Pop(item.ClientId);
if (removedItem != null)
{
player.Inventory.Add(item);
}
}
if (player.Money >= player.Trade.Money)
{
player.AddActionLog("TradeMoney", player.Trade.Money);
player.Money -= player.Trade.Money;
player.Trade.Partner.Money += player.Trade.Money;
}
if (player.Trade.Partner.Money >= player.Trade.PartnerMoney)
{
player.AddActionLog("TradePartnerMoney", player.Trade.PartnerMoney);
player.Trade.Partner.Money -= player.Trade.PartnerMoney;
player.Money += player.Trade.PartnerMoney;
}
if (player.CPs >= player.Trade.CPs)
{
player.AddActionLog("TradeCPs", player.Trade.CPs);
player.CPs -= player.Trade.CPs;
player.Trade.Partner.CPs += player.Trade.CPs;
}
if (player.Trade.Partner.CPs >= player.Trade.PartnerCPs)
{
player.AddActionLog("TradePartnerCPs", player.Trade.PartnerCPs);
player.Trade.Partner.CPs -= player.Trade.PartnerCPs;
player.CPs += player.Trade.PartnerCPs;
}
var partner = player.Trade.Partner;
partner.Trade.Reset();
player.Trade.Reset();
packet.Action = Enums.TradeAction.HideTable;
packet.TargetClientId = partner.ClientId;
player.ClientSocket.Send(packet);
packet.TargetClientId = player.ClientId;
partner.ClientSocket.Send(packet);
player.SendSystemMessage("TRADE_SUCCESS");
partner.SendSystemMessage("TRADE_SUCCESS");
}
else
{
var partner = player.Trade.Partner;
partner.Trade.Reset();
player.Trade.Reset();
packet.Action = Enums.TradeAction.HideTable;
packet.TargetClientId = partner.ClientId;
player.ClientSocket.Send(packet);
packet.TargetClientId = player.ClientId;
partner.ClientSocket.Send(packet);
player.SendSystemMessage("TRADE_FAIL");
partner.SendSystemMessage("TRADE_FAIL");
}
}
return(true);
}
public static bool Handle(Models.Entities.Player player, Models.Packets.Items.ItemActionPacket packet)
{
if (!player.Alive)
{
return(true);
}
if (player.MapId != 1036 || !Tools.RangeTools.ValidDistance(320, 229, player.X, player.Y))
{
return(true);
}
Models.Items.Item blessItem;
if (!player.Inventory.TryGetItem(packet.ClientId, out blessItem))
{
player.SendSystemMessage("BLESS_ITEM_NOT_FOUND");
return(true);
}
if (blessItem.DbOwnerItem.CurrentDura < blessItem.DbOwnerItem.MaxDura)
{
player.SendSystemMessage("BLESS_ITEM_LOW_DURA");
return(true);
}
if (blessItem.IsGarment || blessItem.IsArrow || blessItem.IsBottle || blessItem.IsMountArmor || blessItem.IsMisc ||
blessItem.IsFan || blessItem.IsTower)
{
player.SendSystemMessage("BLESS_ITEM_INVALID");
return(true);
}
int requiredTortoiseGems = 5;
byte setBless = 1;
switch (blessItem.DbOwnerItem.Bless)
{
case 0:
requiredTortoiseGems = 5;
break;
default:
requiredTortoiseGems = blessItem.DbOwnerItem.Bless;
setBless = (byte)(requiredTortoiseGems + 2);
break;
}
if (setBless > 7)
{
player.SendSystemMessage("BLESS_ITEM_MAX_BLESS");
return(true);
}
int tortoiseAmount;
if (!player.Inventory.ContainsById(700073, out tortoiseAmount) || tortoiseAmount < requiredTortoiseGems)
{
player.SendSystemMessage("BLESS_NOT_ENOUGH_TORTOISE_GEMS");
return(true);
}
player.AddActionLog("BlessItem", blessItem.DbOwnerItem.Id);
if (player.Inventory.RemoveByCount(700073, requiredTortoiseGems))
{
blessItem.DbOwnerItem.Bless = setBless;
blessItem.DbOwnerItem.Update();
blessItem.UpdateClient(player, Enums.ItemUpdateAction.Update);
player.ClientSocket.Send(packet);
}
return(true);
}
/// <summary>
/// Adds an item to the warehouse.
/// </summary>
/// <param name="item">The item to add.</param>
/// <returns>True if the item was added, false otherwise.</returns>
public bool Add(Models.Items.Item item, Models.Entities.Player player, bool silentAdd = false)
{
if (_items.Count >= 20)
{
if (player != null)
{
player.SendSystemMessage("WAREHOUSE_FULL");
}
return(false);
}
if (_items.TryAdd(item.ClientId, item))
{
if (item.DbOwnerItem == null)
{
item.DbOwnerItem = new Database.Models.DbOwnerItem
{
PlayerId = Guild.DbGuild.Id,
ItemId = (uint)item.DbItem.Id,
LocationId = Id
};
item.DbOwnerItem.MaxDura = item.DbItem.Amount;
item.DbOwnerItem.CurrentDura = item.DbOwnerItem.MaxDura;
item.Gem1 = Enums.Gem.NoSocket;
item.Gem2 = Enums.Gem.NoSocket;
item.DbOwnerItem.OwnedBy.AddItem(Guild.DbGuild.Name);
if (!item.DbOwnerItem.Create(Database.Models.DbOwnerItem.GuildWarehouse))
{
return(false);
}
}
else if (item.DbOwnerItem.Id == 0)
{
item.DbOwnerItem.PlayerId = Guild.DbGuild.Id;
item.DbOwnerItem.LocationId = Id;
item.DbOwnerItem.OwnedBy.AddItem(Guild.DbGuild.Name);
if (!item.DbOwnerItem.Create(Database.Models.DbOwnerItem.GuildWarehouse))
{
return(false);
}
}
else
{
item.DbOwnerItem.PlayerId = Guild.DbGuild.Id;
item.DbOwnerItem.LocationId = Id;
item.DbOwnerItem.OwnedBy.AddItem(Guild.DbGuild.Name);
if (!item.DbOwnerItem.Update(Database.Models.DbOwnerItem.GuildWarehouse))
{
return(false);
}
}
if (!silentAdd && player != null)
{
player.ClientSocket.Send(new Models.Packets.Items.WarehousePacket
{
WarehouseId = Id,
Item = item
});
}
return(true);
}
return(false);
}