private static void HandleDeclineRequest(GameSession session, PacketReader packet)
{
long otherCharacterId = packet.ReadLong();
Player player = GameServer.PlayerManager.GetPlayerById(otherCharacterId);
player?.Session?.Send(TradePacket.RequestDeclined(session.Player.Name));
}
/// <summary>
/// Handles the AddItem subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
return;
if (!client.Trade.WindowOpen)
return;
uint itemuid = trade.TargetUID;
if (client.Inventory.ContainsByUID(itemuid))
{
Data.ItemInfo item = client.Inventory[itemuid];
if (!item.IsValidOffItem())
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.NO_PERMISSION_ITEM))
{
client.Send(fmsg);
}
return;
}
if ((client.Trade.Partner.Inventory.Count + client.Trade.Items.Count) >= 40)
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.TARGET_FULL_INVENTORY))
{
client.Send(fmsg);
}
return;
}
client.Trade.Items.Add(item);
item.SendPacket(client.Trade.Partner, 2);
}
}
public static void TradePutItem(InPacket lea, Client c)
{
var chr = c.Character;
int SourceType = lea.ReadShort();
int SourceSlot = lea.ReadShort();
int Quantity = lea.ReadInt();
if (SourceType == 0x64 && SourceSlot == 0x64)
{
// Money欄位
chr.Money -= Quantity;
chr.Trade.Money = Quantity;
InventoryPacket.getInvenMoney(c, chr.Money, -Quantity);
TradePacket.TradePutItem(c);
TradePacket.TradePutItem(chr.Trader.Client);
return;
}
Item Source = chr.Items.getItem((byte)SourceType, (byte)SourceSlot);
chr.Trade.SourceQuantity.Add(Source.Quantity);
if (Source != null)
{
chr.Trade.Item.Add(Source);
chr.Trade.TargetQuantity.Add((short)Quantity);
chr.Items.Remove((byte)SourceType, (byte)SourceSlot, Quantity);
InventoryHandler.UpdateInventory(c, (byte)SourceType);
TradePacket.TradePutItem(c);
TradePacket.TradePutItem(chr.Trader.Client);
}
}
/// <summary>
/// Handles the SetMoney subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
{
return;
}
if (!client.Trade.WindowOpen)
{
return;
}
uint money = trade.TargetUID;
if (money > client.Money)
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.LOW_MONEY_TRADE))
{
client.Send(fmsg);
}
return;
}
client.Trade.Money = money;
trade.TradeType = Enums.TradeType.ShowMoney;
client.Trade.Partner.Send(trade);
}
/// <summary>
/// Handles the SetConquerPoints subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
{
return;
}
if (!client.Trade.WindowOpen)
{
return;
}
uint cps = trade.TargetUID;
if (cps > client.CPs)
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.LOW_CPS_TRADE))
{
client.Send(fmsg);
}
return;
}
client.Trade.CPs = cps;
trade.TradeType = Enums.TradeType.ShowConquerPoints;
client.Trade.Partner.Send(trade);
}
public static void TradeSuccessful(InPacket lea, Client c)
{
var chr = c.Character;
TradePacket.TradeSuccessful(c);
TradePacket.TradeSuccessful(chr.Trader.Client);
}
private void handleTradePacket(TradePacket p)
{
//Trade packet recieved server side
if (m.map.getData((int)p.from.X, (int)p.from.Y) == null)
{
return;
}
if (m.map.getData((int)p.to.X, (int)p.to.Y) == null)
{
return;
}
if (m.map.getData((int)p.from.X, (int)p.from.Y).AP == 0)
{
return;
}
Unit u = m.map.getData((int)p.from.X, (int)p.from.Y);
u.AP--;
m.map.setData((int)p.from.X, (int)p.from.Y, u);
u = m.map.getData((int)p.to.X, (int)p.to.Y);
u.AP++;
m.map.setData((int)p.to.X, (int)p.to.Y, u);
updateTile(p.from);
updateTile(p.to);
}
/// <summary>
/// Handles the TimeOut subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (client.Trade.Partner != null)
{
client.Trade.Partner.Trade.Reset();
}
client.Trade.Reset();
}
public static void TradeReady(InPacket lea, Client c)
{
var chr = c.Character;
TradePacket.TradeReady(chr.Trader.Client);
TradePacket.TradeInviteResponses(chr.Trader.Client, 2);
TradePacket.TradeConfirm(chr.Trader.Client);
}
/// <summary>
/// Handles the TimeOut subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (client.Trade.Partner != null)
{
client.Trade.Partner.Trade.Reset();
}
client.Trade.Reset();
}
private static void HandleLockOffer(GameSession session)
{
TradeInventory tradeInventory = session.Player.TradeInventory;
tradeInventory.IsLocked = true;
session.Send(TradePacket.FinalizeOffer(true));
tradeInventory.OtherPlayer.Session?.Send(TradePacket.FinalizeOffer(false));
}
public static TradePacket HandlePacket(Models.Entities.Player player, TradePacket packet, out uint subPacketId)
{
if (player.Battle != null)
{
subPacketId = SubCallState.DontHandle;
return(packet);
}
subPacketId = (uint)packet.Action;
return(packet);
}
public void AlterTrade(GameSession session)
{
if (!OtherPlayer.TradeInventory.IsLocked)
{
return;
}
IsLocked = false;
OtherPlayer.Session?.Send(TradePacket.OfferedAltered(true));
session.Send(TradePacket.OfferedAltered(false));
}
private static void HandleSendRequest(GameSession session, PacketReader packet)
{
long otherCharacterId = packet.ReadLong();
Player player = GameServer.PlayerManager.GetPlayerById(otherCharacterId);
if (player is null)
{
return;
}
session.Send(TradePacket.RequestSent());
player.Session?.Send(TradePacket.TradeRequest(session.Player.Name, session.Player.CharacterId));
}
/// <summary>
/// Handles the Close subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (client.Trade.Partner != null)
{
Entities.GameClient partner = client.Trade.Partner;
partner.Trade.Reset();
client.Trade.Reset();
trade.TradeType = Enums.TradeType.HideTable;
trade.TargetUID = partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
partner.Send(trade);
}
}
public static void TradeInvite(InPacket lea, Client c)
{
int CharacterID = lea.ReadInt();
Map map = MapFactory.GetMap(c.Character.MapX, c.Character.MapY);
foreach (Character chr in map.Characters)
{
if (chr.CharacterID == CharacterID)
{
c.Character.Trader = chr;
chr.Trader = c.Character;
TradePacket.TradeInvite(chr.Client, c.Character.CharacterID);
break;
}
}
}
public bool AddItem(GameSession session, Item item)
{
int index = Array.FindIndex(Items, 0, Items.Length, x => x == null);
if (index == -1)
{
return(false);
}
Items[index] = item;
session.Send(TradePacket.AddItemToTrade(item, index, true));
OtherPlayer.Session?.Send(TradePacket.AddItemToTrade(item, index, false));
AlterTrade(session);
return(true);
}
public bool RemoveItem(GameSession session, long itemUid, int index)
{
if (Items[index]?.Uid != itemUid)
{
return(false);
}
Item item = Items[index];
Items[index] = null;
AlterTrade(session);
session.Send(TradePacket.RemoveItemToTrade(item, index, true));
OtherPlayer.Session?.Send(TradePacket.RemoveItemToTrade(item, index, false));
session.Player.Inventory.AddItem(session, item, false);
return(true);
}
/// <summary>
/// Handles the Close subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (client.Trade.Partner != null)
{
Entities.GameClient partner = client.Trade.Partner;
partner.Trade.Reset();
client.Trade.Reset();
trade.TradeType = Enums.TradeType.HideTable;
trade.TargetUID = partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
partner.Send(trade);
}
}
private static void HandleAcceptRequest(GameSession session, PacketReader packet)
{
long otherCharacterId = packet.ReadLong();
Player otherPlayer = GameServer.PlayerManager.GetPlayerById(otherCharacterId);
if (otherPlayer is null)
{
return;
}
// Create Trade inventory
session.Player.TradeInventory = new(otherPlayer);
otherPlayer.TradeInventory = new(session.Player);
session.Send(TradePacket.RequestAccepted(otherCharacterId));
otherPlayer.Session?.Send(TradePacket.RequestAccepted(session.Player.CharacterId));
}
public static void TradeInviteResponses(InPacket lea, Client c)
{
int Respons = lea.ReadInt();
var chr = c.Character;
if (Respons == 1)
{
chr.Trade = new CharacterTrade();
chr.Trader.Trade = new CharacterTrade();
}
if (Respons == 1)
{
TradePacket.TradeInviteResponses(c, Respons);
}
TradePacket.TradeInviteResponses(c.Character.Trader.Client, Respons);
}
private static void HandleModifyMesosToTrade(GameSession session, PacketReader packet)
{
long mesoAmount = packet.ReadLong();
if (mesoAmount > session.Player.Wallet.Meso.Amount || session.Player.TradeInventory.IsLocked)
{
return;
}
Player otherPlayer = session.Player.TradeInventory.OtherPlayer;
session.Player.TradeInventory.AlterTrade(session);
session.Player.TradeInventory.Mesos = mesoAmount;
session.Send(TradePacket.AddMesosToTrade(mesoAmount, true));
otherPlayer.Session?.Send(TradePacket.AddMesosToTrade(mesoAmount, false));
}
/// <summary>
/// Handles the SetMoney subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
return;
if (!client.Trade.WindowOpen)
return;
uint money = trade.TargetUID;
if (money > client.Money)
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.LOW_MONEY_TRADE))
{
client.Send(fmsg);
}
return;
}
client.Trade.Money = money;
trade.TradeType = Enums.TradeType.ShowMoney;
client.Trade.Partner.Send(trade);
}
/// <summary>
/// Handles the SetConquerPoints subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
return;
if (!client.Trade.WindowOpen)
return;
uint cps = trade.TargetUID;
if (cps > client.CPs)
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.LOW_CPS_TRADE))
{
client.Send(fmsg);
}
return;
}
client.Trade.CPs = cps;
trade.TradeType = Enums.TradeType.ShowConquerPoints;
client.Trade.Partner.Send(trade);
}
//TradePacket
private static void HandlePacket(TradePacket packet)
{
if (!string.IsNullOrEmpty(packet.TradePartner))
{
Globals.Trade = new Item[2, Options.MaxInvItems];
//Gotta initialize the trade values
for (var x = 0; x < 2; x++)
{
for (var y = 0; y < Options.MaxInvItems; y++)
{
Globals.Trade[x, y] = new Item();
}
}
Interface.Interface.GameUi.NotifyOpenTrading(packet.TradePartner);
}
else
{
Interface.Interface.GameUi.NotifyCloseTrading();
}
}
/// <summary>
/// Handles the AddItem subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
{
return;
}
if (!client.Trade.WindowOpen)
{
return;
}
uint itemuid = trade.TargetUID;
if (client.Inventory.ContainsByUID(itemuid))
{
Data.ItemInfo item = client.Inventory[itemuid];
if (!item.IsValidOffItem())
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.NO_PERMISSION_ITEM))
{
client.Send(fmsg);
}
return;
}
if ((client.Trade.Partner.Inventory.Count + client.Trade.Items.Count) >= 40)
{
using (var fmsg = Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.TARGET_FULL_INVENTORY))
{
client.Send(fmsg);
}
return;
}
client.Trade.Items.Add(item);
item.SendPacket(client.Trade.Partner, 2);
}
}
private static void HandleFinalizeTrade(GameSession session)
{
TradeInventory tradeInventory = session.Player.TradeInventory;
Player otherPlayer = tradeInventory.OtherPlayer;
if (!otherPlayer.Session.Connected())
{
HandleCloseTrade(session);
return;
}
TradeInventory otherPlayerTradeInventory = tradeInventory.OtherPlayer?.TradeInventory;
if (otherPlayerTradeInventory is null)
{
return;
}
if (!otherPlayerTradeInventory.IsLocked && !tradeInventory.IsLocked)
{
return;
}
session.Send(TradePacket.FinalizeTrade(true));
otherPlayer.Session.Send(TradePacket.FinalizeTrade(false));
// Trade items
GetSumMesos(session.Player, -tradeInventory.Mesos, otherPlayerTradeInventory.Mesos);
otherPlayerTradeInventory.SendItems(session.Player, true);
GetSumMesos(otherPlayer, -otherPlayerTradeInventory.Mesos, tradeInventory.Mesos);
tradeInventory.SendItems(otherPlayer, true);
session.Send(TradePacket.TradeStatus(true));
otherPlayer.Session?.Send(TradePacket.TradeStatus(true));
session.Player.TradeInventory = null;
otherPlayer.TradeInventory = null;
}
private static void HandleCloseTrade(GameSession session)
{
TradeInventory tradeInventory = session.Player.TradeInventory;
if (tradeInventory is null)
{
return;
}
Player otherPlayer = tradeInventory.OtherPlayer;
// Return items back to player's inventory
tradeInventory.SendItems(session.Player, false);
tradeInventory = null;
if (otherPlayer?.TradeInventory is null)
{
return;
}
session.Send(TradePacket.TradeStatus(false));
otherPlayer.Session?.Send(TradePacket.TradeStatus(false));
}
/// <summary>
/// Handles the Request subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (client.Trade.Trading && client.Trade.Partner == null)
{
using (var fmsg = Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.SELF_ALREADY_TRADE))
client.Send(fmsg);
return;
}
else if (client.Trade.Trading)
{
if (!client.Trade.Requesting)
{
trade.TradeType = Enums.TradeType.ShowTable;
trade.TargetUID = client.Trade.Partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
client.Trade.Partner.Send(trade);
client.Trade.WindowOpen = true;
client.Trade.Partner.Trade.WindowOpen = true;
}
return;
}
if (client.Map.MapObjects.ContainsKey(trade.TargetUID)) //(Core.Kernel.Clients.Contains(trade.TargetUID))
{
Maps.IMapObject obj;
if (client.Map.MapObjects.TryGetValue(trade.TargetUID, out obj)) //(Core.Kernel.Clients.TrySelect(trade.TargetUID, out target))
{
if (!obj.IsInMap(client))
{
return;
}
if (client.Map.MapType == Enums.MapType.Shared)
{
return;
}
Entities.GameClient target = (Entities.GameClient)obj;
if (!target.Trade.Trading)
{
client.Trade.Begin(target);
target.Trade.Begin(client);
target.Trade.Requesting = false;
client.Trade.Requesting = true;
trade.TargetUID = client.EntityUID;
target.Send(trade);
}
else
{
using (var fmsg = Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.ALREADY_TRADE))
client.Send(fmsg);
}
}
else
{
using (var fmsg = Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.TARGET_BUSY))
client.Send(fmsg);
}
}
else
{
client.NetworkClient.Disconnect(string.Format("Invalid trade target. TargetUID {0}", trade.TargetUID));
}
}
public void ProcessTradePacket(Player sender, TradePacket packet)
{
switch (packet.Subtype)
{
#region Trade Request
case TradeType.Request:
if (Target == null) //No request has already been sent!
{
if (PlayerManager.Players.ContainsKey(packet.Target))
{
Target = PlayerManager.GetUser(packet.Target);
}
else //Target is not a client
{
Owner.SendMessage("Invalid target for trade!", ChatType.System);
Owner.Trade = null;
return;
}
if (Target.Trade == null) //Target is not trading! Lets send request
{
packet.Target = Owner.UID;
Target.Send(packet);
Target.Trade = this;
}
else //Target is trading, Shut down this request!
{
Owner.SendMessage(Target.Name + " is already trading, please try later", ChatType.System);
Owner.Trade = null;
return;
}
}
else
{
packet.Subtype = TradeType.ShowTable;
packet.Target = Target.UID;
Owner.Send(packet);
packet.Target = Owner.UID;
Target.Send(packet);
}
break;
#endregion
#region Trade Timeout
case TradeType.TimeOut:
Owner.Trade = null;
if (Target != null)
{
Target.Trade = null;
}
break;
#endregion
#region AddItem
case TradeType.AddItem:
{
var _item = sender.GetItemByUID(packet.Target);
if (_item != null && _item.IsTradeable)
{
if (sender == Owner)
{
if (Target.Inventory.Count + OwnerItems.Count < 40)
{
OwnerItems.Add(_item);
Target.Send(ItemInformationPacket.Create(_item, ItemInfoAction.Trade));
}
else //full inv on Target
{
Owner.SendMessage(Target.Name + " cannot hold more items", ChatType.System);
}
}
else if (sender == Target)
{
if (Owner.Inventory.Count + TargetItems.Count < 40)
{
TargetItems.Add(_item);
Owner.Send(ItemInformationPacket.Create(_item, ItemInfoAction.Trade));
}
else //full inv on Target
{
Owner.SendMessage(Target.Name + " cannot hold more items", ChatType.System);
}
}
}
break;
}
#endregion
#region Accept
case TradeType.Accept:
{
if (!Accepted)
{
if (sender == Owner)
{
packet.Target = Owner.UID;
Target.Send(packet);
}
else if (sender == Target)
{
packet.Target = Target.UID;
Owner.Send(packet);
}
Accepted = true;
}
else
{
bool success = true;
foreach (Structures.ConquerItem _item in OwnerItems)
{
if (!Owner.Inventory.ContainsKey(_item.UniqueID))
{
success = false;
break;
}
}
foreach (Structures.ConquerItem _item in TargetItems)
{
if (!Target.Inventory.ContainsKey(_item.UniqueID))
{
success = false;
break;
}
}
if (Owner.Money < OwnerMoney)
{
success = false;
}
if (Target.Money < TargetMoney)
{
success = false;
}
if (Owner.CP < OwnerCP)
{
success = false;
}
if (Target.CP < TargetCP)
{
success = false;
}
packet.Subtype = TradeType.HideTable;
Owner.Send(packet);
Target.Send(packet);
if (success)
{
foreach (Structures.ConquerItem _item in TargetItems)
{
Owner.AddItem(_item);
Owner.Send(ItemInformationPacket.Create(_item, ItemInfoAction.AddItem));
_item.SetOwner(Owner);
Target.Send(new ItemActionPacket
{
ActionType = ItemAction.RemoveInventory, //might be wrong
UID = _item.UniqueID,
});
//Target.Send(ItemActionPacket.Create(_item.UniqueID, _item.StaticID, ItemAction.RemoveInventory));
if (!Target.RemoveItem(_item))
{
Console.WriteLine("Error with removing player item. " + Target.Name);
}
}
foreach (Structures.ConquerItem _item in OwnerItems)
{
Target.AddItem(_item);
Target.Send(ItemInformationPacket.Create(_item, ItemInfoAction.AddItem));
_item.SetOwner(Target);
Owner.Send(new ItemActionPacket
{
ActionType = ItemAction.RemoveInventory, //might be wrong
UID = _item.UniqueID,
});
//Owner.Send(ItemActionPacket.Create(_item.UniqueID, _item.StaticID, ItemAction.RemoveInventory));
if (!Owner.RemoveItem(_item))
{
Console.WriteLine("Error with removing player item. " + Owner.Name);
}
}
Owner.Money -= OwnerMoney;
Target.Money += OwnerMoney;
Target.Money -= TargetMoney;
Owner.Money += TargetMoney;
Target.CP -= TargetCP;
Owner.CP += TargetCP;
Owner.CP -= OwnerCP;
Target.CP += OwnerCP;
Target.SendMessage("Trade Successful", ChatType.System);
Owner.SendMessage("Trade Successful", ChatType.System);
}
else
{
Target.SendMessage("Trade Failed", ChatType.System);
Owner.SendMessage("Trade Failed", ChatType.System);
}
Owner.Trade = null;
Target.Trade = null;
}
break;
}
#endregion
#region AddCp
case TradeType.SetConquerPoints:
{
packet.Subtype = TradeType.ShowConquerPoints;
if (sender.CP >= packet.Target)
{
if (Owner == sender)
{
OwnerCP = packet.Target;
Target.Send(packet);
}
else if (Target == sender)
{
TargetCP = packet.Target;
Owner.Send(packet);
}
}
else
{
Console.WriteLine("not enough cp");
}
break;
}
#endregion
#region AddMoney
case TradeType.SetMoney:
{
packet.Subtype = TradeType.ShowMoney;
if (sender.Money >= packet.Target)
{
if (Owner == sender)
{
OwnerMoney = packet.Target;
Target.Send(packet);
}
else if (Target == sender)
{
TargetMoney = packet.Target;
Owner.Send(packet);
}
}
else
{
Console.WriteLine("not enough gold");
}
break;
}
#endregion
#region Close Trade
case TradeType.Close:
Owner.Trade = null;
if (Target != null)
{
packet.Subtype = TradeType.HideTable;
packet.Target = Target.UID;
Owner.Send(packet);
packet.Target = Owner.UID;
Target.Send(packet);
Target.Trade = null;
}
break;
#endregion
default:
Console.WriteLine("Unhandled Trade Type: " + packet.Subtype);
break;
}
}
private void handleTradePacket(TradePacket p)
{
//Trade packet received client side (shouldn't ever happen)
throw new Exception("Trade packet recieved client side.");
}
public static void TradeCancel(InPacket lea, Client c)
{
var chr = c.Character;
int j = 0;
// 個人
chr.Money += chr.Trade.Money;
// 對方
chr.Trader.Money += chr.Trader.Trade.Money;
// 個人
if (chr.Trade.Money > 0)
{
InventoryPacket.getInvenMoney(c, chr.Money, chr.Trade.Money);
}
// 對方
if (chr.Trader.Trade.Money > 0)
{
InventoryPacket.getInvenMoney(chr.Trader.Client, chr.Trader.Money, chr.Trader.Trade.Money);
}
// 個人
foreach (Item Item in chr.Trade.Item)
{
Item i = chr.Items.getItem(Item.Type, Item.Slot);
if (i != null)
{
// 合併消費物品、其他物品
if (chr.Trade.SourceQuantity[j] + chr.Trade.TargetQuantity[j] <= 100)
{
chr.Items.Remove(Item.Type, Item.Slot);
chr.Items.Add(new Item(Item.ItemID, chr.Trade.SourceQuantity[j], Item.Spirit, Item.Level1,
Item.Level2, Item.Level3, Item.Level4, Item.Level5, Item.Level6, Item.Level7, Item.Level8,
Item.Level9, Item.Level10, Item.Fusion, Item.IsLocked, Item.Icon, Item.Term, Item.Type,
Item.Slot));
}
else
{
chr.Items.Add(Item);
}
}
else
{
chr.Items.Add(Item);
}
InventoryHandler.UpdateInventory(c, Item.Type);
j++;
}
int k = 0;
// 對方
foreach (Item Item in chr.Trader.Trade.Item)
{
Item i = chr.Trader.Items.getItem(Item.Type, Item.Slot);
if (i != null)
{
// 合併消費物品、其他物品
if (chr.Trader.Trade.SourceQuantity[k] + chr.Trader.Trade.TargetQuantity[k] <= 100)
{
chr.Trader.Items.Remove(Item.Type, Item.Slot);
chr.Trader.Items.Add(new Item(Item.ItemID, chr.Trader.Trade.SourceQuantity[k], Item.Spirit,
Item.Level1, Item.Level2, Item.Level3, Item.Level4, Item.Level5, Item.Level6, Item.Level7,
Item.Level8, Item.Level9, Item.Level10, Item.Fusion, Item.IsLocked, Item.Icon, Item.Term,
Item.Type, Item.Slot));
}
else
{
chr.Trader.Items.Add(Item);
}
}
else
{
chr.Trader.Items.Add(Item);
}
InventoryHandler.UpdateInventory(chr.Trader.Client, Item.Type);
k++;
}
TradePacket.TradeCancel(chr.Trader.Client);
chr.Trade = null;
chr.Trader = null;
}
public static void TradeConfirm(InPacket lea, Client c)
{
var chr = c.Character;
int j = 0;
int k = 0;
int m = 0;
int l = 0;
try
{
// 交易成功
// Item
// 個人接收
foreach (Item Item in chr.Trader.Trade.Item)
{
byte Type = Item.Type;
byte Slot = chr.Items.GetNextFreeSlot((InventoryType.ItemType)Type);
chr.Items.Add(new Item(Item.ItemID, chr.Trader.Trade.TargetQuantity[m], Item.Spirit, Item.Level1,
Item.Level2, Item.Level3, Item.Level4, Item.Level5, Item.Level6, Item.Level7, Item.Level8,
Item.Level9, Item.Level10, Item.Fusion, Item.IsLocked, Item.Icon, Item.Term, Type, Slot));
InventoryHandler.UpdateInventory(c, Item.Type);
m++;
}
// 對方接收
foreach (Item Item in chr.Trade.Item)
{
byte Type = Item.Type;
byte Slot = chr.Trader.Items.GetNextFreeSlot((InventoryType.ItemType)Type);
chr.Trader.Items.Add(new Item(Item.ItemID, chr.Trade.TargetQuantity[l], Item.Spirit, Item.Level1,
Item.Level2, Item.Level3, Item.Level4, Item.Level5, Item.Level6, Item.Level7, Item.Level8,
Item.Level9, Item.Level10, Item.Fusion, Item.IsLocked, Item.Icon, Item.Term, Type, Slot));
InventoryHandler.UpdateInventory(chr.Trader.Client, Item.Type);
l++;
}
// Money
// 個人
chr.Money += chr.Trader.Trade.Money;
// 對方
chr.Trader.Money += chr.Trade.Money;
// 個人
if (chr.Trader.Trade.Money > 0)
{
InventoryPacket.getInvenMoney(c, chr.Money, chr.Trader.Trade.Money);
}
// 對方
if (chr.Trade.Money > 0)
{
InventoryPacket.getInvenMoney(chr.Trader.Client, chr.Trader.Money, chr.Trade.Money);
}
}
catch
{
// 交易失敗
// Item
// 個人
foreach (Item Item in chr.Trade.Item)
{
Item i = chr.Items.getItem(Item.Type, Item.Slot);
if (i != null)
{
// 合併消費物品、其他物品
if (chr.Trade.SourceQuantity[j] + chr.Trade.TargetQuantity[j] <= 100)
{
chr.Items.Remove(Item.Type, Item.Slot);
chr.Items.Add(new Item(Item.ItemID, chr.Trade.SourceQuantity[j], Item.Spirit, Item.Level1,
Item.Level2, Item.Level3, Item.Level4, Item.Level5, Item.Level6, Item.Level7,
Item.Level8, Item.Level9, Item.Level10, Item.Fusion, Item.IsLocked, Item.Icon,
Item.Term, Item.Type, Item.Slot));
}
else
{
chr.Items.Add(Item);
}
}
else
{
chr.Items.Add(Item);
}
InventoryHandler.UpdateInventory(c, Item.Type);
j++;
}
// 對方
foreach (Item Item in chr.Trader.Trade.Item)
{
Item i = chr.Trader.Items.getItem(Item.Type, Item.Slot);
if (i != null)
{
// 合併消費物品、其他物品
if (chr.Trader.Trade.SourceQuantity[k] + chr.Trader.Trade.TargetQuantity[k] <= 100)
{
chr.Trader.Items.Remove(Item.Type, Item.Slot);
chr.Trader.Items.Add(new Item(Item.ItemID, chr.Trader.Trade.SourceQuantity[k], Item.Spirit,
Item.Level1, Item.Level2, Item.Level3, Item.Level4, Item.Level5, Item.Level6,
Item.Level7, Item.Level8, Item.Level9, Item.Level10, Item.Fusion, Item.IsLocked,
Item.Icon, Item.Term, Item.Type, Item.Slot));
}
else
{
chr.Trader.Items.Add(Item);
}
}
else
{
chr.Trader.Items.Add(Item);
}
InventoryHandler.UpdateInventory(chr.Trader.Client, Item.Type);
k++;
}
// Money
// 個人
chr.Money += chr.Trade.Money;
// 對方
chr.Trader.Money += chr.Trader.Trade.Money;
// 個人
if (chr.Trade.Money > 0)
{
InventoryPacket.getInvenMoney(c, chr.Money, chr.Trade.Money);
}
// 對方
if (chr.Trader.Trade.Money > 0)
{
InventoryPacket.getInvenMoney(chr.Trader.Client, chr.Trader.Money, chr.Trader.Trade.Money);
}
TradePacket.TradeFail(c);
TradePacket.TradeFail(chr.Trader.Client);
return;
}
TradePacket.TradeSuccessful(c);
TradePacket.TradeSuccessful(chr.Trader.Client);
}
/// <summary>
/// Handles the Accept subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
{
return;
}
if (!client.Trade.WindowOpen)
{
return;
}
if (!client.Trade.Accepted && !client.Trade.PartnerAccepted)
{
client.Trade.Accepted = true;
client.Trade.Partner.Trade.Accepted = true;
trade.TargetUID = client.EntityUID;
client.Trade.Partner.Send(trade);
}
else if (client.Trade.Accepted && client.Trade.Partner.Trade.Accepted)
{
Console.WriteLine(trade.TargetUID);
bool trade_success = true;
foreach (Data.ItemInfo item in client.Trade.Items)
{
if (!client.Inventory.ContainsByUID(item.UID))
{
trade_success = false;
}
}
foreach (Data.ItemInfo item in client.Trade.PartnerItems)
{
if (!client.Trade.Partner.Inventory.ContainsByUID(item.UID))
{
trade_success = false;
}
}
if (client.Money < client.Trade.Money)
{
trade_success = false;
}
if (client.Trade.Partner.Money < client.Trade.PartnerMoney)
{
trade_success = false;
}
if (client.CPs < client.Trade.CPs)
{
trade_success = false;
}
if (client.Trade.Partner.CPs < client.Trade.PartnerCPs)
{
trade_success = false;
}
if (trade_success)
{
if (!client.NetworkClient.Connected)
{
return;
}
if (!client.Trade.Partner.NetworkClient.Connected)
{
return;
}
foreach (Data.ItemInfo item in client.Trade.Items)
{
if (!client.Inventory.ContainsByUID(item.UID))
{
continue; // double checking
}
if (client.Inventory.RemoveItemByUID(item.UID) != null)
{
client.Trade.Partner.Inventory.AddItem(item);
}
}
foreach (Data.ItemInfo item in client.Trade.PartnerItems)
{
if (!client.Trade.Partner.Inventory.ContainsByUID(item.UID))
{
continue; // double checking
}
if (client.Trade.Partner.Inventory.RemoveItemByUID(item.UID) != null)
{
client.Inventory.AddItem(item);
}
}
if (client.Money >= client.Trade.Money)
{
client.Money -= client.Trade.Money;
client.Trade.Partner.Money += client.Trade.Money;
}
if (client.Trade.Partner.Money >= client.Trade.PartnerMoney)
{
client.Trade.Partner.Money -= client.Trade.PartnerMoney;
client.Money += client.Trade.PartnerMoney;
}
if (client.CPs >= client.Trade.CPs)
{
client.CPs -= client.Trade.CPs;
client.Trade.Partner.CPs += client.Trade.CPs;
}
if (client.Trade.Partner.CPs >= client.Trade.PartnerCPs)
{
client.Trade.Partner.CPs -= client.Trade.PartnerCPs;
client.CPs += client.Trade.PartnerCPs;
}
Entities.GameClient partner = client.Trade.Partner;
partner.Trade.Reset();
client.Trade.Reset();
trade.TradeType = Enums.TradeType.HideTable;
trade.TargetUID = partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
partner.Send(trade);
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", client.Name, Core.MessageConst.TRADE_SUCCESS))
{
client.Send(tmsg);
}
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", partner.Name, Core.MessageConst.TRADE_SUCCESS))
{
partner.Send(tmsg);
}
}
else
{
Entities.GameClient partner = client.Trade.Partner;
partner.Trade.Reset();
client.Trade.Reset();
trade.TradeType = Enums.TradeType.HideTable;
trade.TargetUID = partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
partner.Send(trade);
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", client.Name, Core.MessageConst.TRADE_FAIL))
{
client.Send(tmsg);
}
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", partner.Name, Core.MessageConst.TRADE_FAIL))
{
partner.Send(tmsg);
}
}
}
}
/// <summary>
/// Handles the Request subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (client.Trade.Trading && client.Trade.Partner == null)
{
using (var fmsg = Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.SELF_ALREADY_TRADE))
client.Send(fmsg);
return;
}
else if (client.Trade.Trading)
{
if (!client.Trade.Requesting)
{
trade.TradeType = Enums.TradeType.ShowTable;
trade.TargetUID = client.Trade.Partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
client.Trade.Partner.Send(trade);
client.Trade.WindowOpen = true;
client.Trade.Partner.Trade.WindowOpen = true;
}
return;
}
if (client.Map.MapObjects.ContainsKey(trade.TargetUID))//(Core.Kernel.Clients.Contains(trade.TargetUID))
{
Maps.IMapObject obj;
if (client.Map.MapObjects.TryGetValue(trade.TargetUID, out obj))//(Core.Kernel.Clients.TrySelect(trade.TargetUID, out target))
{
if (!obj.IsInMap(client))
return;
if (client.Map.MapType == Enums.MapType.Shared)
return;
Entities.GameClient target = (Entities.GameClient)obj;
if (!target.Trade.Trading)
{
client.Trade.Begin(target);
target.Trade.Begin(client);
target.Trade.Requesting = false;
client.Trade.Requesting = true;
trade.TargetUID = client.EntityUID;
target.Send(trade);
}
else
{
using (var fmsg = Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.ALREADY_TRADE))
client.Send(fmsg);
}
}
else
{
using (var fmsg = Message.MessageCore.CreateSystem2(client.Name, Core.MessageConst.TARGET_BUSY))
client.Send(fmsg);
}
}
else
{
client.NetworkClient.Disconnect(string.Format("Invalid trade target. TargetUID {0}", trade.TargetUID));
}
}
/// <summary>
/// Handles the Accept subtype of the TradePacket.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="trade">The trade packet.</param>
public static void Handle(Entities.GameClient client, TradePacket trade)
{
if (!client.Trade.Trading)
return;
if (!client.Trade.WindowOpen)
return;
if (!client.Trade.Accepted && !client.Trade.PartnerAccepted)
{
client.Trade.Accepted = true;
client.Trade.Partner.Trade.Accepted = true;
trade.TargetUID = client.EntityUID;
client.Trade.Partner.Send(trade);
}
else if (client.Trade.Accepted && client.Trade.Partner.Trade.Accepted)
{
Console.WriteLine(trade.TargetUID);
bool trade_success = true;
foreach (Data.ItemInfo item in client.Trade.Items)
{
if (!client.Inventory.ContainsByUID(item.UID))
trade_success = false;
}
foreach (Data.ItemInfo item in client.Trade.PartnerItems)
{
if (!client.Trade.Partner.Inventory.ContainsByUID(item.UID))
trade_success = false;
}
if (client.Money < client.Trade.Money)
trade_success = false;
if (client.Trade.Partner.Money < client.Trade.PartnerMoney)
trade_success = false;
if (client.CPs < client.Trade.CPs)
trade_success = false;
if (client.Trade.Partner.CPs < client.Trade.PartnerCPs)
trade_success = false;
if (trade_success)
{
if (!client.NetworkClient.Connected)
return;
if (!client.Trade.Partner.NetworkClient.Connected)
return;
foreach (Data.ItemInfo item in client.Trade.Items)
{
if (!client.Inventory.ContainsByUID(item.UID))
continue; // double checking
if (client.Inventory.RemoveItemByUID(item.UID) != null)
{
client.Trade.Partner.Inventory.AddItem(item);
}
}
foreach (Data.ItemInfo item in client.Trade.PartnerItems)
{
if (!client.Trade.Partner.Inventory.ContainsByUID(item.UID))
continue; // double checking
if (client.Trade.Partner.Inventory.RemoveItemByUID(item.UID) != null)
{
client.Inventory.AddItem(item);
}
}
if (client.Money >= client.Trade.Money)
{
client.Money -= client.Trade.Money;
client.Trade.Partner.Money += client.Trade.Money;
}
if (client.Trade.Partner.Money >= client.Trade.PartnerMoney)
{
client.Trade.Partner.Money -= client.Trade.PartnerMoney;
client.Money += client.Trade.PartnerMoney;
}
if (client.CPs >= client.Trade.CPs)
{
client.CPs -= client.Trade.CPs;
client.Trade.Partner.CPs += client.Trade.CPs;
}
if (client.Trade.Partner.CPs >= client.Trade.PartnerCPs)
{
client.Trade.Partner.CPs -= client.Trade.PartnerCPs;
client.CPs += client.Trade.PartnerCPs;
}
Entities.GameClient partner = client.Trade.Partner;
partner.Trade.Reset();
client.Trade.Reset();
trade.TradeType = Enums.TradeType.HideTable;
trade.TargetUID = partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
partner.Send(trade);
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", client.Name, Core.MessageConst.TRADE_SUCCESS))
{
client.Send(tmsg);
}
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", partner.Name, Core.MessageConst.TRADE_SUCCESS))
{
partner.Send(tmsg);
}
}
else
{
Entities.GameClient partner = client.Trade.Partner;
partner.Trade.Reset();
client.Trade.Reset();
trade.TradeType = Enums.TradeType.HideTable;
trade.TargetUID = partner.EntityUID;
client.Send(trade);
trade.TargetUID = client.EntityUID;
partner.Send(trade);
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", client.Name, Core.MessageConst.TRADE_FAIL))
{
client.Send(tmsg);
}
using (var tmsg = Message.MessageCore.Create(Enums.ChatType.TopLeft, System.Drawing.Color.LimeGreen, "SYSTEM", partner.Name, Core.MessageConst.TRADE_FAIL))
{
partner.Send(tmsg);
}
}
}
}
