/// <summary>
/// Called when Blackwood Trade arrives (contains price info)
/// </summary>
private void OnTradeUpdate(object sender, MsgTrade trade)
{
try
{
lock (trade)
{
Security security = new Security();
security.Symbol = trade.Symbol.Value;
Tick tick = new Tick(security, Constants.MarketDataProvider.Blackwood, trade.Time.Value)
{
LastPrice = Convert.ToDecimal(trade.Price.Value),
LastSize = Convert.ToDecimal(trade.TradeSize.Value),
};
// Raise Tick Arrived Event
if (TickArrived != null)
{
TickArrived(tick);
}
}
// Log incoming price event
if (Logger.IsDebugEnabled)
{
Logger.Debug(String.Format("Trade Arrived for: {0} | Price: {1} | Time: {2}",
trade.Symbol.Value, Convert.ToDecimal(trade.Price.Value),
trade.Time.Value),
_type.FullName, "OnTradeUpdate");
}
}
catch (Exception exception)
{
Logger.Error(exception, _type.FullName, "OnTradeUpdate");
}
}
public void SendTradeMsg(MsgTrade tradeMsg)
{
try
{
lock (_clientSocket.GetStream())
{
//Get stream
NetworkStream str = _clientSocket.GetStream();
IFormatter fmt = new BinaryFormatter();
MemoryStream memStr = new MemoryStream();
//Serialize object to the memorystream for sizing
fmt.Serialize(memStr, tradeMsg);
byte[] data = memStr.GetBuffer();
//get header info in bytes
int memSize = (int)memStr.Length;
byte[] size = BitConverter.GetBytes(memSize);
byte[] type = BitConverter.GetBytes((int)MsgType.Trade);
byte[] header = new Byte[8];
size.CopyTo(header, 0);
type.CopyTo(header, 4);
Console.WriteLine("memsize = " + memSize);
//send header
str.Write(header, 0, 8);
//send data
str.Write(data, 0, memSize);
str.Flush();
memStr.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void Release()
{
var msg = new MsgTrade(0, MsgTrade.Action.False);
if (mFirstPlayer != null)
{
mFirstPlayer.TradeRequest = 0;
mFirstPlayer.Send(msg);
if (!mIsSuccess)
{
mFirstPlayer.SendSysMsg(StrRes.STR_TRADE_FAIL);
}
mFirstPlayer.Deal = null;
}
if (mSecondPlayer != null)
{
mSecondPlayer.TradeRequest = 0;
mSecondPlayer.Send(msg);
if (!mIsSuccess)
{
mSecondPlayer.SendSysMsg(StrRes.STR_TRADE_FAIL);
}
mSecondPlayer.Deal = null;
}
}
private void bnOffer_Click(object sender, System.EventArgs e)
{
this.bnOffer.Enabled = false;
Trade trade = new Trade(this._thisPlayerID, Trader.NextTradeShipID, this._client.PlayerName, this._targetPlayerID,
(int)this.offerMineral.Value, (int)this.offerOrganic.Value, (int)this.offerEnergy.Value,
(int)this.returnMineral.Value, (int)this.returnOrganic.Value, (int)this.returnEnergy.Value);
this._tradeMsg = new MsgTrade(MsgTrade.TradeMsgType.Offer, trade, String.Empty);
this._client.SendTradeMsg(_tradeMsg);
}
/// <summary>
/// call this to accept a trade message from another player
/// Keep in mind this will be closed as a Modal dialog and will be returned
/// as soon as an accept button is pressed. This will block this Players ability
/// to accept other messages. hmmm, this could cause problem.. possible discon-
/// nections?
/// </summary>
/// <param name="trade"></param>
/// <param name="gameData"></param>
/// <param name="client"></param>
/// <param name="thisPlayerID"></param>
public TradeDialog(MsgTrade tradeMsg, GameData gameData, WormholeClient client, int thisPlayerID)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this._tradeMsg = tradeMsg;
Trade trade = tradeMsg.Trade;
this._gameData = gameData;
this._client = client;
this._thisPlayerID = thisPlayerID;
if (this._thisPlayerID == tradeMsg.Trade.OfferingPartyID)
{
this._targetPlayerID = tradeMsg.Trade.AskedPartyID;
}
else
{
this._targetPlayerID = tradeMsg.Trade.OfferingPartyID;
}
this.Text += _gameData.PlayerList[_targetPlayerID].Name;
this.offerMineral.Value = trade.AskedMineral;
this.offerOrganic.Value = trade.AskedOrganic;
this.offerEnergy.Value = trade.AskedEnergy;
this.returnMineral.Value = trade.OfferedMineral;
this.returnOrganic.Value = trade.OfferedOrganic;
this.returnEnergy.Value = trade.OfferedEnergy;
this._exMin = _gameData.PlayerList[_thisPlayerID].Fleet.ExMineral - trade.AskedMineral + trade.OfferedMineral;
this._exOrg = _gameData.PlayerList[_thisPlayerID].Fleet.ExOrganic - trade.AskedOrganic + trade.OfferedOrganic;
this._exEng = _gameData.PlayerList[_thisPlayerID].Fleet.ExEnergy - trade.AskedEnergy + trade.OfferedEnergy;
this.surplusMineral.Text = _exMin.ToString();
this.surplusOrganic.Text = _exOrg.ToString();
this.surplusEnergy.Text = _exEng.ToString();
if (tradeMsg.Type == MsgTrade.TradeMsgType.Offer)
{
this.bnCancel.Enabled = false;
this.bnOffer.Enabled = false;
this.bnReject.Enabled = true;
this.bnAccept.Enabled = true;
this.bnIgnore.Enabled = true;
this.bnIgnore.Text = "Busy, Try Later";
}
if (_exMin < 0 || _exOrg < 0 || _exEng < 0)
{
this.bnAccept.Enabled = false;
}
}
public void ShowTable()
{
var msg = new MsgTrade
{
Type = TradeType.SHOW_TABLE,
Target = m_pOwner.Identity
};
m_pTarget.Send(msg);
msg.Target = m_pTarget.Identity;
m_pOwner.Send(msg);
}
public void CloseWindow(MsgTrade msg)
{
m_pOwner.Trade = null;
if (m_pTarget != null)
{
msg.Type = TradeType.HIDE_TABLE;
msg.Target = m_pTarget.Identity;
m_pOwner.Send(msg);
msg.Target = m_pOwner.Identity;
m_pTarget.Owner.Send(msg);
m_pTarget.Trade = null;
}
}
private void bnCancel_Click(object sender, System.EventArgs e)
{
Trade trade = (Trade)this.listBox1.SelectedItem;
this.bnCancel.Enabled = false;
if (trade == null)
{
return;
}
MsgTrade tradeMsg = new MsgTrade(MsgTrade.TradeMsgType.Cancel, trade, String.Empty);
this._client.SendTradeMsg(tradeMsg);
}
public void CloseWindow()
{
var msg = new MsgTrade {
Type = TradeType.HIDE_TABLE, Target = m_pTarget.Identity
};
m_pOwner.Send(msg);
msg.Target = m_pOwner.Identity;
m_pTarget.Send(msg);
m_pTarget.Trade = null;
m_pOwner.Trade = null;
}
/// <summary>
/// Serves as confirmation for accepting and cancelling trades sending out duplicate
/// notices to each party when an acceptance or cancelation notice is received from
/// one of the trade partners
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void OnTradeMessage(object sender, TradeMessageEventArgs e)
{
MsgTrade tradeMsg = e.TradeMsg;
switch (tradeMsg.Type)
{
case MsgTrade.TradeMsgType.Accept:
//assign an ID
//tradeMsg.Trade.TradeID = _gameData.NextTradeID;
//add to list
//this._tradeList.Add(tradeMsg.Trade);
//send confirmation
//this._playerIDArray[tradeMsg.Trade.OfferingPartyID].SendTradeMsg(tradeMsg);
//this._playerIDArray[tradeMsg.Trade.AskedPartyID].SendTradeMsg(tradeMsg);
//break;
case MsgTrade.TradeMsgType.Cancel:
{
//int removeID = tradeMsg.Trade.TradeID; //this info will now be kept on
//find trade //and transfered with the trade
/*foreach(object trade in this._tradeList)
* {
* Trade t = (Trade)trade;
* //Remove trade from trade list
* if(t.TradeID == removeID)
* _tradeList.Remove(trade);
* }*/
//Notify each trade partner of the cancellation
this._playerIDArray[tradeMsg.Trade.OfferingPartyID].SendTradeMsg(tradeMsg);
this._playerIDArray[tradeMsg.Trade.AskedPartyID].SendTradeMsg(tradeMsg);
break;
}
case MsgTrade.TradeMsgType.Offer:
case MsgTrade.TradeMsgType.Reject:
case MsgTrade.TradeMsgType.Busy:
case MsgTrade.TradeMsgType.Message:
{
//forward tradeMsg to target player
this._playerIDArray[tradeMsg.Trade.AskedPartyID].SendTradeMsg(tradeMsg);
break;
}
}
}
public static bool Execute(Player player, int npcId, byte control, string input)
{
try
{
Console.WriteLine("control:" + control);
switch (control)
{
case 0:
{
using (var yi = new NpcDialog(20))
{
yi
.Text($"Hello {player.Name.TrimEnd('\0')}, do you have anything for me?")
.Link("Yes!", 1)
.Link("No.", 255)
.Finish();
player.Send(yi);
}
break;
}
case 1:
Console.WriteLine("Opening Tradewindow");
Npc found;
if (GameWorld.Find(player.CurrentNpcId, out found))
{
player.Trade = new Trade(player, found);
var packet = MsgTrade.Create(player.CurrentNpcId, TradeMode.ShowTradeWindow);
player.ForceSend(packet, packet.Size);
}
break;
}
return(true);
}
catch
{
return(false);
}
}
public bool AddMoney(uint dwAmount, Character pSender, MsgTrade pMsg)
{
if (dwAmount > pSender.Silver)
{
pSender.Send(ServerString.STR_NOT_ENOUGH_MONEY);
return(false);
}
if (pSender == m_pOwner)
{
if (m_pTarget.Silver + dwAmount > int.MaxValue)
{
CloseWindow();
return(false);
}
m_dwOwnerMoney = dwAmount;
pMsg.Type = TradeType.SHOW_MONEY;
m_pTarget.Send(pMsg);
}
else if (pSender == m_pTarget)
{
if (m_pOwner.Silver + dwAmount > int.MaxValue)
{
CloseWindow();
return(false);
}
m_dwTargetMoney = dwAmount;
pMsg.Type = TradeType.SHOW_MONEY;
m_pOwner.Send(pMsg);
}
else
{
// dude?
return(false);
}
return(true);
}
public bool AddEmoney(uint dwAmount, Character pSender, MsgTrade pMsg)
{
if (dwAmount > pSender.Emoney)
{
pSender.Send(ServerString.STR_NOT_ENOUGH_EMONEY);
return(false);
}
if (pSender == m_pOwner)
{
if (m_pTarget.Emoney + dwAmount > int.MaxValue)
{
CloseWindow();
return(false);
}
m_dwOwnerEmoney = dwAmount;
pMsg.Type = TradeType.SHOW_CONQUER_POINTS;
m_pTarget.Send(pMsg);
}
else if (pSender == m_pTarget)
{
if (m_pOwner.Emoney + dwAmount > int.MaxValue)
{
CloseWindow();
return(false);
}
m_dwTargetEmoney = dwAmount;
pMsg.Type = TradeType.SHOW_CONQUER_POINTS;
m_pOwner.Send(pMsg);
}
else
{
return(false);
}
return(true);
}
private void ProcessMessage(byte [] data)
{
//Deserialize message
IFormatter fmt = new BinaryFormatter();
MemoryStream memHolder = new MemoryStream(data, 0, data.Length);
memHolder.Position = 0;
switch (_msgType)
{
case MsgType.Ping:
{
Console.WriteLine("Pong");
break;
}
case MsgType.Text:
{
MsgText msg = (MsgText)fmt.Deserialize(memHolder);
//if this is the first message assign it to client name
if (_firstTime)
{
_userName = msg.Text;
_firstTime = false;
_connected = true;
if (eConnected != null)
{
EventArgs e = new EventArgs();
eConnected(this, e);
}
}
else if (eMessageReceived != null && _connected)
{
//Else raise the MessageReceived Event
//and pass the message along
MessageEventArgs e = new MessageEventArgs(msg);
eMessageReceived(this, e);
}
break;
}
case MsgType.Orders:
{
//
// TODO: make sure it isn't possible to get more
// than one set of orders in the list for a
// single player
//
//accept fleet data from player and add to
//arraylist of fleetdata
if (_fleet != null && _orders.Contains(_fleet))
{
Console.WriteLine("Old fleet orders removed for player " + this._clientID);
_orders.Remove(_fleet);
}
Console.WriteLine("Attempting to Deserialize Orders from player");
this._fleet = (Fleet)fmt.Deserialize(memHolder);
ClientHost._orders.Add(_fleet);
Console.WriteLine("Fleet added to server orders");
this._ready = true;
if (eReady != null)
{
EventArgs e = new EventArgs();
eReady(this, e);
}
break;
}
case MsgType.Cancel:
{
ClientHost._orders.Remove(this._fleet);
Console.WriteLine("Fleet orders removed for player " + this._clientID);
this._ready = false;
break;
}
case MsgType.PlayerIDRequest:
{
NameAndID nameAndID = (NameAndID)fmt.Deserialize(memHolder);
int id = nameAndID.ID;
string password = nameAndID.Password;
if (eIDRequest != null)
{
Console.WriteLine(_userName + " requests player ID(event fired)");
IDRequestEventArgs e = new IDRequestEventArgs(id, password);
eIDRequest(this, e);
}
break;
}
case MsgType.SystemName:
{
MsgSystemName sysName = (MsgSystemName)fmt.Deserialize(memHolder);
if (this.eRenameSystem != null)
{
SystemNameEventArgs mea = new SystemNameEventArgs(sysName);
this.eRenameSystem(this, mea);
}
break;
}
case MsgType.Trade:
{
MsgTrade tradeMsg = (MsgTrade)fmt.Deserialize(memHolder);
if (this.eTradeMessage != null)
{
TradeMessageEventArgs ea = new TradeMessageEventArgs(tradeMsg);
this.eTradeMessage(this, ea);
}
break;
}
}
memHolder.Close();
//Determine message type
//Carry out message instructions
}
public bool AddItem(uint id, Character pSender)
{
Item item;
if (pSender.Inventory.Items.TryGetValue(id, out item))
{
if (item.Bound)
{
var msg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(msg);
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
if (item.Itemtype.Monopoly == 3 || item.Itemtype.Monopoly == 9)
{
var msg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(msg);
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
TradePartner partner;
if (pSender == m_pOwner)
{
if ((m_pTarget.Inventory.RemainingSpace() - m_dicTarget.Count - 1) >= 40)
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
pSender.Send(ServerString.STR_TRADE_TARGET_BAG_FULL);
m_pTarget.Send(ServerString.STR_TRADE_YOUR_BAG_IS_FULL);
return(false);
}
if (item.IsLocked() &&
(!pSender.TradePartners.TryGetValue(m_pTarget.Identity, out partner) ||
!partner.IsActive))
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
if (!item.CanBeSold)
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
if (m_dicOwner.ContainsKey(id))
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
// item already exists
return(false);
}
m_dicOwner.Add(id, item);
var msg = item.InformationPacket();
msg.ItemMode = ItemMode.TRADE;
m_pTarget.Send(msg);
}
else if (pSender == m_pTarget)
{
if (m_pOwner.Inventory.RemainingSpace() - m_dicOwner.Count - 1 >= 40)
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
pSender.Send(ServerString.STR_TRADE_YOUR_BAG_IS_FULL);
m_pTarget.Send(ServerString.STR_TRADE_TARGET_BAG_FULL);
return(false);
}
if (item.IsLocked() &&
(!pSender.TradePartners.TryGetValue(m_pOwner.Identity, out partner) ||
!partner.IsActive))
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
if (!item.CanBeSold)
{
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
if (m_dicTarget.ContainsKey(id))
{
// item already exists
var pmsg = new MsgTrade
{
Target = id,
Type = TradeType.REMOVE_ITEM
};
pSender.Send(pmsg);
return(false);
}
m_dicTarget.Add(id, item);
var msg = item.InformationPacket();
msg.ItemMode = ItemMode.TRADE;
m_pOwner.Send(msg);
}
else
{
return(false); // who the f**k?
}
return(true);
}
pSender.Send(ServerString.STR_NOT_FOR_TRADE);
return(false);
}
public bool AcceptTrade(Character pSender, MsgTrade pMsg)
{
if (!m_bAccepted)
{
if (pSender == m_pOwner)
{
pMsg.Target = pSender.Identity;
m_pTarget.Send(pMsg);
m_bOwnerConfirmed = true;
if (!m_bTargetConfirmed)
{
return(true);
}
}
else if (pSender == m_pTarget)
{
pMsg.Target = pSender.Identity;
m_pOwner.Send(pMsg);
m_bTargetConfirmed = true;
if (!m_bOwnerConfirmed)
{
return(true);
}
}
else
{
return(false);
}
m_bAccepted = true;
}
/*
* Changed the steps a little bit from the old version. In the old version if p1 inserts items and
* send the acceptance packet twice it would confirm the trade :) 2016-04-19
*/
if (!m_bAccepted)
{
return(false); // should not reach here if both didn't accept
}
// checks if both accounts still has the items on the inventory
bool success = m_dicOwner.Values.All(item => m_pOwner.Inventory.Items.ContainsKey(item.Identity));
if (!success)
{
m_pOwner.Send(ServerString.STR_TRADE_FAIL);
m_pTarget.Send(ServerString.STR_TRADE_FAIL);
CloseWindow();
return(false);
}
success = m_dicTarget.Values.All(item => m_pTarget.Inventory.Items.ContainsKey(item.Identity));
// checks if both accounts still have space in the inventory
if (m_pOwner.Inventory.RemainingSpace() < m_dicTarget.Count)
{
success = false;
}
if (m_pTarget.Inventory.RemainingSpace() < m_dicOwner.Count)
{
success = false;
}
// checks for money and emoney
if (m_dwOwnerMoney > m_pOwner.Silver)
{
success = false;
}
if (m_dwOwnerEmoney > m_pOwner.Emoney)
{
success = false;
}
if (m_dwTargetMoney > m_pTarget.Silver)
{
success = false;
}
if (m_dwTargetEmoney > m_pTarget.Emoney)
{
success = false;
}
if (!success)
{
m_pOwner.Send(ServerString.STR_TRADE_FAIL);
m_pTarget.Send(ServerString.STR_TRADE_FAIL);
CloseWindow();
return(false);
}
ServerKernel.Log.GmLog("trade_item",
string.Format("user1_id[{0}] user1[{1}] lev1[{2}] money1[{3}] emoney1[{4}]", m_pOwner.Identity, m_pOwner.Name, m_pOwner.Level, m_dwOwnerMoney, m_dwOwnerEmoney));
ServerKernel.Log.GmLog("trade_item",
string.Format("user2_id[{0}] user2[{1}] lev2[{2}] money2[{3}] emoney2[{4}]", m_pTarget.Identity, m_pTarget.Name, m_pTarget.Level, m_dwTargetMoney, m_dwTargetEmoney));
CloseWindow();
foreach (var item in m_dicOwner.Values)
{
m_pOwner.Inventory.Remove(item.Identity, ItemRemovalType.TAKE_OUT_FROM_INVENTORY_ONLY);
item.OwnerIdentity = m_pOwner.Identity;
item.PlayerIdentity = m_pTarget.Identity;
m_pTarget.Inventory.Add(item);
ServerKernel.Log.GmLog("trade_item",
string.Format(
"user_id[{0}] name[{1}]| item[{2}][{3}] type[{4}] gem1[{5}] gem2[{6}] magic3[{7}] dur[{8}] max_dur[{9}] data[{10}], dec_dmg[{11}] add_life[{12}] color[{13}] Addlevel_exp[{14}] artifact_type[{15}] artifact_expire[{16}] artifact_stabilization[{17}] refinery_type[{18}] refinery_level[{19}] refinery_stabilization[{20}] stack_amount[{21}] remaining_time[{22}]",
m_pOwner.Identity, m_pOwner.Name, item.Itemtype.Name, item.Identity, item.Type, item.SocketOne,
item.SocketTwo, item.Plus, item.Durability, item.MaximumDurability, item.SocketProgress,
item.ReduceDamage, item.Enchantment, item.Color, item.CompositionProgress,
item.ArtifactType, item.Artifact.ArtifactExpireTime, item.ArtifactStabilization,
item.RefineryType, item.RefineryLevel, item.RefineryStabilization, item.StackAmount,
item.RemainingTime));
}
foreach (var item in m_dicTarget.Values)
{
m_pTarget.Inventory.Remove(item.Identity, ItemRemovalType.TAKE_OUT_FROM_INVENTORY_ONLY);
item.OwnerIdentity = m_pTarget.Identity;
item.PlayerIdentity = m_pOwner.Identity;
m_pOwner.Inventory.Add(item);
ServerKernel.Log.GmLog("trade_item",
string.Format("user_id[{0}] name[{1}]| item[{2}][{3}] type[{4}] gem1[{5}] gem2[{6}] magic3[{7}] dur[{8}] max_dur[{9}] data[{10}], dec_dmg[{11}] add_life[{12}] color[{13}] Addlevel_exp[{14}] artifact_type[{15}] artifact_expire[{16}] artifact_stabilization[{17}] refinery_type[{18}] refinery_level[{19}] refinery_stabilization[{20}] stack_amount[{21}] remaining_time[{22}]",
m_pTarget.Identity, m_pTarget.Name, item.Itemtype.Name, item.Identity, item.Type, item.SocketOne, item.SocketTwo, item.Plus, item.Durability, item.MaximumDurability, item.SocketProgress, item.ReduceDamage, item.Enchantment, item.Color, item.CompositionProgress, 0, 0, 0, 0, 0, 0, 0, 0));
}
m_pOwner.ReduceMoney(m_dwOwnerMoney);
m_pOwner.ReduceEmoney(m_dwOwnerEmoney);
m_pTarget.ReduceMoney(m_dwTargetMoney);
m_pTarget.ReduceEmoney(m_dwTargetEmoney);
m_pOwner.AwardMoney(m_dwTargetMoney);
m_pOwner.AwardEmoney(m_dwTargetEmoney);
m_pTarget.AwardMoney(m_dwOwnerMoney);
m_pTarget.AwardEmoney(m_dwOwnerEmoney);
m_pOwner.Send(ServerString.STR_TRADE_SUCCEED);
m_pTarget.Send(ServerString.STR_TRADE_SUCCEED);
return(true);
}
public TradeMessageEventArgs(MsgTrade tradeMsg)
{
_tradeMsg = tradeMsg;
}
public Boolean TradeOK()
{
if (mFirstPlayer == null || mSecondPlayer == null)
{
return(false);
}
if (mFirstPlayer.Map != mSecondPlayer.Map)
{
return(false);
}
if (!MyMath.CanSee(mFirstPlayer.X, mFirstPlayer.Y, mSecondPlayer.X, mSecondPlayer.Y, 18))
{
return(false);
}
//Check Money
if (mFirstPlayer.Money < mFirstPlayerMoney || mSecondPlayer.Money < mSecondPlayerMoney)
{
return(false);
}
if (mFirstPlayer.Money + mSecondPlayerMoney > Player._MAX_MONEYLIMIT || mSecondPlayer.Money + mFirstPlayerMoney > Player._MAX_MONEYLIMIT)
{
return(false);
}
//Check Items (1)
if (mSecondPlayer.ItemInInventory() + mFirstPlayerItems.Count > 40)
{
return(false);
}
foreach (Int32 UniqId in mFirstPlayerItems)
{
Item Item = null;
if (!mFirstPlayer.Items.TryGetValue(UniqId, out Item))
{
return(false);
}
if (Item.Position != 0)
{
return(false);
}
}
//Check Items (2)
if (mFirstPlayer.ItemInInventory() + mSecondPlayerItems.Count > 40)
{
return(false);
}
foreach (Int32 UniqId in mSecondPlayerItems)
{
Item Item = null;
if (!mSecondPlayer.Items.TryGetValue(UniqId, out Item))
{
return(false);
}
if (Item.Position != 0)
{
return(false);
}
}
//Execute Trade
if (mFirstPlayerMoney != 0)
{
mSecondPlayer.Money += mFirstPlayerMoney;
mFirstPlayer.Money -= mFirstPlayerMoney;
}
if (mSecondPlayerMoney != 0)
{
mFirstPlayer.Money += mSecondPlayerMoney;
mSecondPlayer.Money -= mSecondPlayerMoney;
}
//mFirstPlayer.Send(new MsgUserAttrib(mFirstPlayer, mFirstPlayer.Money, MsgUserAttrib.Type.Money));
//mSecondPlayer.Send(new MsgUserAttrib(mSecondPlayer, mSecondPlayer.Money, MsgUserAttrib.Type.Money));
String Items1 = "[";
foreach (Int32 UniqId in mFirstPlayerItems)
{
Item Item = null;
if (!mFirstPlayer.Items.TryGetValue(UniqId, out Item))
{
return(false);
}
Items1 += UniqId + ":";
mFirstPlayer.DelItem(Item, true);
mSecondPlayer.AddItem(Item, true);
}
String Items2 = "[";
foreach (Int32 UniqId in mSecondPlayerItems)
{
Item Item = null;
if (!mSecondPlayer.Items.TryGetValue(UniqId, out Item))
{
return(false);
}
Items2 += UniqId + ":";
mSecondPlayer.DelItem(Item, true);
mFirstPlayer.AddItem(Item, true);
}
mFirstPlayer.SendSysMsg(StrRes.STR_TRADE_SUCCEED);
mSecondPlayer.SendSysMsg(StrRes.STR_TRADE_SUCCEED);
var msg = new MsgTrade(0, MsgTrade.Action.Success);
mFirstPlayer.Send(msg);
mSecondPlayer.Send(msg);
mIsSuccess = true;
Database.Save(mFirstPlayer, true);
Database.Save(mSecondPlayer, true);
return(true);
}
public static void HandleTrade(Character pSender, MsgTrade pMsg)
{
switch (pMsg.Type)
{
#region Request
case TradeType.REQUEST:
{
Client pUserTarget;
if (!ServerKernel.Players.TryGetValue(pMsg.Target, out pUserTarget))
{
return;
}
if (pUserTarget.Character == null)
{
pSender.Send(ServerString.STR_NO_TRADE_TARGET);
return;
}
Character pAcceptRole = pUserTarget.Character;
if (pAcceptRole.FetchTradeRequest(pSender.Identity))
{
pSender.Trade = pAcceptRole.Trade = new Trade(pSender, pAcceptRole);
pSender.Trade.ShowTable();
pAcceptRole.ClearTradeRequest();
return;
}
if (pUserTarget.Character == null)
{
return;
}
Character pRoleTarget = pUserTarget.Character;
if (pRoleTarget.Trade == null)
{
pMsg.Target = pSender.Identity;
pRoleTarget.Send(pMsg);
pRoleTarget.SendRelation(pSender);
pSender.SetTradeRequest(pRoleTarget.Identity);
pSender.Send(ServerString.STR_TRADING_REQEST_SENT);
return;
}
else
{
pSender.Send(ServerString.STR_TARGET_TRADING);
return;
}
break;
}
#endregion
#region Time out
case TradeType.TIME_OUT:
{
GamePacketHandler.Report(pMsg);
//Console.WriteLine("Trade close due to timeout");
//pSender.Trade.CloseWindow(pMsg);
break;
}
#endregion
#region Accept Trade
case TradeType.ACCEPT:
{
pSender.Trade.AcceptTrade(pSender, pMsg);
break;
}
#endregion
#region Add Item
case TradeType.ADD_ITEM:
{
pSender.Trade.AddItem(pMsg.Target, pSender);
break;
}
#endregion
#region Set Money
case TradeType.SET_MONEY:
{
pSender.Trade.AddMoney(pMsg.Target, pSender, pMsg);
break;
}
#endregion
#region Set Conquer Points
case TradeType.SET_CONQUER_POINTS:
{
pSender.Trade.AddEmoney(pMsg.Target, pSender, pMsg);
break;
}
#endregion
#region Close
case TradeType.CLOSE:
{
if (pSender.Trade != null)
{
pSender.Trade.CloseWindow(pMsg);
}
break;
}
#endregion
}
}
public void UpdateTradeMsg(MsgTrade tradeMsg)
{
this._tradeMsg = tradeMsg;
switch (tradeMsg.Type)
{
case MsgTrade.TradeMsgType.Accept:
{
this._client.SetUpTrade(tradeMsg.Trade, this.ActivePlayerID);
this.listBox1.Items.Add(tradeMsg.Trade);
this.chatBox.AppendText("\r\nTrade agreement confirmed");
break;
}
case MsgTrade.TradeMsgType.Reject:
{
this.chatBox.AppendText(tradeMsg.Msg);
Console.WriteLine("Rejection received");
break;
}
case MsgTrade.TradeMsgType.Message:
{
this.chatBox.AppendText(tradeMsg.Msg);
break;
}
case MsgTrade.TradeMsgType.Offer:
{
Trade trade = tradeMsg.Trade;
this.offerMineral.Value = trade.AskedMineral;
this.offerOrganic.Value = trade.AskedOrganic;
this.offerEnergy.Value = trade.AskedEnergy;
this.returnMineral.Value = trade.OfferedMineral;
this.returnOrganic.Value = trade.OfferedOrganic;
this.returnEnergy.Value = trade.OfferedEnergy;
this.bnAccept.Enabled = true;
this.bnReject.Enabled = true;
this.bnCancel.Enabled = false;
this.bnOffer.Enabled = false;
break;
}
case MsgTrade.TradeMsgType.Cancel:
{
this.listBox1.Items.Clear();
this.bnCancel.Enabled = false;
Fleet fleet = _gameData.PlayerList[_thisPlayerID].Fleet;
for (int i = 0; i < fleet.Count; i++)
{
if (fleet[i].Type == Ship.ShipType.Trader)
{
Trader trader = (Trader)fleet[i];
this.listBox1.Items.Add(trader.Trade);
}
}
this.chatBox.AppendText("\r\nTrade canceled");
Console.WriteLine("Cancel message received by dialog box");
int newExMin = this._exEng + (int)this.returnMineral.Value - (int)this.offerMineral.Value;
this.surplusEnergy.Text = newExMin.ToString();
int newExOrg = this._exOrg + (int)this.returnOrganic.Value - (int)this.offerOrganic.Value;
this.surplusEnergy.Text = newExOrg.ToString();
int newExEng = this._exEng + (int)this.returnEnergy.Value - (int)this.offerEnergy.Value;
this.surplusEnergy.Text = newExEng.ToString();
break;
}
}
}
