void HandleTradeRemoveCommand(string msg, TradeSession trade)
{
string[] args = msg.Split(' ');
if (args.Length < 2)
{
trade.SendChatMessage("Invalid arguments.");
return;
}
var pattern = string.Format(".*{0}.*",
msg.Substring(msg.IndexOf(" ")).Trim());
if (string.IsNullOrWhiteSpace(pattern))
{
return;
}
UpdateBackpack();
var assets = GetAssetsMatchingPattern(pattern);
foreach (var asset in assets)
{
var item = GetItemFromDefIndex(asset.DefIndex);
Logger.WriteLine("Removing from trade: {0}", item.Name);
trade.RemoveItem(asset.Id);
}
}
void HandleTradeMessage(TradeSession trade, TradeEvent @event)
{
Logger.WriteLine("{0} says in trade: {1}",
SteamFriends.GetFriendPersonaName(trade.OtherSteamId),
@event.message);
HandleTradeTextCommand(trade, @event);
}
private DateTime GetStartDate(string timeframe, IList <TradeSession> sessions, DateTime currentDate)
{
IDictionary <string, int> _frameDic = new Dictionary <string, int>();
_frameDic.Add("5", 5);
_frameDic.Add("60", 60);
TradeSession lastSession = sessions.Last();
//if (lastSession.Date.AddHours(19) < currentDate)
//{
// currentDate = lastSession.Date.AddHours(19).AddMinutes(-1);
//}
//if (lastSession.Date.AddHours(10) > currentDate)
//{
// currentDate = sessions[sessions.Count -2].Date.AddHours(19).AddMinutes(-1);
//}
//количество фреймов
int count = 80;
//текущая сессия
var ss = sessions.Where(s => currentDate >= s.Date.AddHours(10) && currentDate < s.Date.AddHours(19)).ToList();
TradeSession curentSession = sessions.Single(s => currentDate >= s.Date.AddHours(10) && currentDate < s.Date.AddHours(19));
int curIndex = sessions.IndexOf(curentSession);
DateTime curentSessionDt = curentSession.Date.AddHours(10);
int currPart = (currentDate.Hour * 60 + currentDate.Minute) - (curentSessionDt.Hour * 60 + curentSessionDt.Minute);
//длина сессии
int sessionlength = 9 * 60;
//длина смещения
int sessiondiv = _frameDic[timeframe] * count;
//полных сессий
int fullSession = sessiondiv / sessionlength;
//часть сессии
int partSession = sessiondiv % sessionlength;
DateTime res;
if (currPart < partSession)
{
res = sessions[curIndex - fullSession - 1].Date.AddHours(19).AddMinutes(currPart - partSession);
}
else
{
res = sessions[curIndex - fullSession].Date.AddHours(10).AddMinutes(currPart - partSession);
}
return(res);
}
void HandleTradeEvent(TradeSession trade, TradeEvent @event)
{
switch (@event.type)
{
case ETradeEventType.Initialized:
HandleTradeInitialized(trade, @event);
break;
case ETradeEventType.Message:
HandleTradeMessage(trade, @event);
break;
case ETradeEventType.ItemAdded:
HandleTradeItemAdded(trade, @event);
break;
case ETradeEventType.ItemRemoved:
var itemRemoved = trade.ForeignInventory.LookupItem(@event.item);
Logger.WriteLine("Item removed: " + itemRemoved.details.name);
break;
case ETradeEventType.Confirmed:
HandleTradeConfirmed(trade, @event);
break;
case ETradeEventType.InventoryLoaded:
Logger.WriteLine("Inventory loaded: " + @event.ToString());
break;
case ETradeEventType.ForeignInventoryLoaded:
Logger.WriteLine("Foreign Inventory loaded: " + @event.ToString());
break;
case ETradeEventType.Ready:
Logger.WriteLine("Trader is ready to trade.");
break;
case ETradeEventType.Unready:
Logger.WriteLine("Trader is not ready to trade.");
break;
case ETradeEventType.Finished:
var s = string.Format("Trade is finished: " + trade.Status);
if (trade.Status == ETradeTransactionStatus.Finished)
{
s += string.Format(" id = {0}", @event.tradeId);
}
Logger.WriteLine(s);
break;
default:
Logger.WriteLine("Unhandled trade event: " + @event);
break;
}
}
protected void signalPerformanceOptimization(TA.PriceVolumeSeries series, double[] data, int windowSize)
{
double stopLossFrom = 0.02;
double stopLossTo = 0.04;
double stopLossStep = 0.001;
double buySignalFrom = 0.9;;
double buySignalTo = 1.1;
double sellSignalFrom = 0.9;
double sellSignalTo = 1.1;
double signalStep = 0.002;
int maxDays = 1000;
int daysFrom = 1;
int daysTo = 10;
int daysStep = 1;
long loopsTotal = (long)(((buySignalTo - buySignalFrom) / signalStep) * ((sellSignalFrom - sellSignalTo) / signalStep) * ((stopLossTo - stopLossFrom) / stopLossStep) * (daysFrom - daysTo));
System.Collections.Generic.List <TradeSession> bestBlocks = new System.Collections.Generic.List <TradeSession>(40);
double buySignal = buySignalFrom;
while (buySignal < buySignalTo)
{
double sellSignal = sellSignalFrom;
while (sellSignal < sellSignalTo)
{
double stopLoss = stopLossFrom;
while (stopLoss < stopLossTo)
{
int days = daysFrom;
while (days < daysTo)
{
signalPerformanceOptimization(series, data, windowSize, stopLoss, maxDays, sellSignal, buySignal, days, bestBlocks);
loopsTotal--;
if ((loopsTotal & 0xFFFF) == 0)
{
System.Console.Write("." + loopsTotal);
}
days = days + daysStep;
}
stopLoss += stopLossStep;
}
sellSignal += signalStep;
}
buySignal += signalStep;
}
TradeSession bs = findBest(bestBlocks);
System.Console.WriteLine("pTotal=" + (int)(100 * bs.p) + ", days=" + bs.days +
", hits=" + bs.hits + ", maxDrawDown=" + (int)(100 * bs.maxDrawDown) + "" +
", trades=" + bs.trades.Count + ", stopLoss=" + bs.stopLoss + ", maxDays=" + bs.maxDays +
", sellSig=" + bs.sellSignal + ", buySig=" + bs.buySignal + ", wind=" + windowSize);
signalPerformancePrintTrades(bs.trades);
}
void HandleTradeInitialized(TradeSession trade, TradeEvent @event)
{
if (trade.Inventory != null)
{
return;
}
foreach (var ctx in @event.inventoryApps)
{
Logger.WriteLine("Loading inventory: " + ctx.name);
trade.LoadInventory(SteamUser.SteamID, ctx.appid, ctx.contexts[0].id);
return;
}
}
internal async Task <ExchangeOrder> BuyLimitOrderAsync(TradeSession tradeSession, decimal amount, decimal price)
{
var executedOrder = await _exchange.BuyLimitOrderAsync(tradeSession.PairCode, amount, price);
if (executedOrder.Id == 0)
{
throw new Exception("Buy order not executed (order id = 0)");
}
BuyLimitOrderPlaced?.Invoke(this, new BitstampOrderEventArgs(executedOrder));
tradeSession.LastBuyTimestamp = DateTime.Now;
return(executedOrder);
}
/// <summary>
/// 更新会话信息
/// </summary>
/// <param name="tradeToken"></param>
/// <param name="session"></param>
/// <returns></returns>
public bool UpdateSession(string tradeToken, TradeSession session)
{
if (string.IsNullOrWhiteSpace(tradeToken))
{
return(false);
}
string key = GetRedisKey(tradeToken);
if (session.ExpireTime.TotalMinutes > 0)
{
return(this.distributedCache.Set <TradeSession>(key, session, session.ExpireTime));
}
return(this.distributedCache.Set <TradeSession>(key, session));
}
internal Trade(SteamID me, SteamID other, string sessionId, string token, Inventory myInventory, Inventory otherInventory)
{
mySteamId = me;
OtherSID = other;
session = new TradeSession(sessionId, token, other, "440");
this.eventList = new List <TradeEvent>();
OtherOfferedItems = new List <ulong>();
myOfferedItems = new Dictionary <int, ulong>();
steamMyOfferedItems = new List <ulong>();
OtherInventory = otherInventory;
MyInventory = myInventory;
}
internal Trade(SteamID me, SteamID other, string sessionId, string token, Inventory myInventory, Inventory otherInventory)
{
mySteamId = me;
OtherSID = other;
session = new TradeSession(sessionId, token, other, "440");
this.eventList = new List<TradeEvent>();
OtherOfferedItems = new List<ulong>();
myOfferedItems = new Dictionary<int, ulong>();
steamMyOfferedItems = new List<ulong>();
OtherInventory = otherInventory;
MyInventory = myInventory;
}
void HandleTradeItemsCommand(string msg, TradeSession trade)
{
trade.SendChatMessage("Not implemented yet!");
return;
var sb = new StringBuilder();
sb.AppendLine("Items:");
foreach (var item in trade.ItemsToReceive)
{
sb.AppendLine(string.Format("{0} | {1}", item.id,
item.details.name));
}
trade.SendChatMessage(sb.ToString());
}
public Dialog_TradeAerialVehicle(AerialVehicleInFlight aerialVehicle, Pawn playerNegotiator, ITrader trader, bool giftsOnly = false)
{
this.aerialVehicle = aerialVehicle;
this.giftsOnly = giftsOnly;
TradeSession.SetupWith(trader, playerNegotiator, giftsOnly);
SetupPlayerCaravanVariables();
forcePause = true;
absorbInputAroundWindow = true;
soundAppear = SoundDefOf.CommsWindow_Open;
soundClose = SoundDefOf.CommsWindow_Close;
if (trader is PassingShip)
{
soundAmbient = SoundDefOf.RadioComms_Ambience;
}
sorter1 = TransferableSorterDefOf.Category;
sorter2 = TransferableSorterDefOf.MarketValue;
}
public async Task GetTradeSession()
{
TradeSession.Clear();
// Account trade session
TTTradeSession tradeSession = await _client.GetTradeSessionAsync();
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.PlatformName), tradeSession.PlatformName));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.PlatformCompany), tradeSession.PlatformCompany));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.PlatformAddress), tradeSession.PlatformAddress));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.PlatformTimezoneOffset), tradeSession.PlatformTimezoneOffset));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.SessionId), tradeSession.SessionId));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.SessionStatus), tradeSession.SessionStatus));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.SessionStartTime), tradeSession.SessionStartTime.ToString("u")));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.SessionEndTime), tradeSession.SessionEndTime.ToString("u")));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.SessionOpenTime), tradeSession.SessionOpenTime.ToString("u")));
TradeSession.Add(new KeyValuePair <string, object>(nameof(tradeSession.SessionCloseTime), tradeSession.SessionCloseTime.ToString("u")));
}
internal Trade(SteamID me, SteamID other, string sessionId, string token, GenericInventory myInventory, GenericInventory otherInventory)
{
TradeStarted = false;
OtherIsReady = false;
MeIsReady = false;
mySteamId = me;
OtherSID = other;
session = new TradeSession(sessionId, token, other);
this.eventList = new List <TradeEvent>();
OtherOfferedItems = new List <GenericInventory.GenericItem>();
MyOfferedItems = new List <GenericInventory.GenericItem>();
steamMyOfferedItems = new Dictionary <int, GenericInventory.GenericItem>();
MyInventory = myInventory;
OtherInventory = otherInventory;
}
void HandleTradeItemAdded(TradeSession trade, TradeEvent @event)
{
if (@event.item.appid != TF2App)
{
Logger.WriteLine("Ignored item: not TF2 item...");
return;
}
var asset = trade.ForeignInventory.LookupItem(@event.item);
var item = GetItemFromAsset(asset);
if (item == null)
{
Logger.WriteLine("Unknown item added: " + @event.item);
return;
}
Logger.WriteLine("Item added: " + item.ItemName);
}
internal Trade(SteamID me, SteamID other, SteamWeb steamWeb, Task <Inventory> myInventoryTask, Task <Inventory> otherInventoryTask)
{
TradeStarted = false;
OtherIsReady = false;
MeIsReady = false;
mySteamId = me;
OtherSID = other;
session = new TradeSession(other, steamWeb);
this.eventList = new List <TradeEvent>();
myOfferedItemsLocalCopy = new Dictionary <int, TradeUserAssets>();
otherOfferedItems = new List <TradeUserAssets>();
myOfferedItems = new List <TradeUserAssets>();
this.otherInventoryTask = otherInventoryTask;
this.myInventoryTask = myInventoryTask;
}
internal Trade(SteamID me, SteamID other, string sessionId, string token, Task <Inventory> myInventoryTask, Task <Inventory> otherInventoryTask)
{
TradeStarted = false;
OtherIsReady = false;
MeIsReady = false;
mySteamId = me;
OtherSID = other;
session = new TradeSession(sessionId, token, other);
this.eventList = new List <TradeEvent>();
OtherOfferedItems = new List <ulong>();
steamMyOfferedItems = new Dictionary <int, ulong>();
MyOfferedItems = new List <ulong>();
this.otherInventoryTask = otherInventoryTask;
this.myInventoryTask = myInventoryTask;
}
protected void _signalPerformanceOptimization(TA.PriceVolumeSeries series, double[] data, int windowSize)
{
double stopLossStep = 0.001;
System.Collections.Generic.List <TradeSession> bestBlocks = new System.Collections.Generic.List <TradeSession>(40);
double buySignal = -1.94;
double sellSignal = 1.7;
double stopLoss = 0.026;
signalPerformanceOptimization(series, data, windowSize, stopLoss, 1000, 1.05, 0.9, 3, bestBlocks);
TradeSession bs = findBest(bestBlocks);
System.Console.WriteLine("pTotal=" + (int)(100 * bs.p) + ", days=" + bs.days +
", hits=" + bs.hits + ", maxDrawDown=" + (int)(100 * bs.maxDrawDown) + "" +
", trades=" + bs.trades.Count + ", stopLoss=" + bs.stopLoss + ", maxDays=" + bs.maxDays +
", sellSig=" + bs.sellSignal + ", buySig=" + bs.buySignal + ", wind=" + windowSize);
signalPerformancePrintTrades(bs.trades);
}
/// <summary>
/// This function will initialize the trading.
/// First it will check if the desired target is a existing target and fill it
/// to your characer.target, by using is Character we check if the target is a valid
/// Character or a other type of actor.
///
/// If the selected character is a non-character or the target is yourself
/// we'll send a reason of NO_TARGET. If the selected target already has a tradesession
/// active we send a TRADE_ACTIVE. IF everything goes according to plans we'll not set
/// a reason which equals sucess.
/// </summary>
/// <param name="cpkt"></param>
private void CM_TRADEINVITATION(CMSG_REQUESTTRADE cpkt)
{
if (Regiontree.TryFind(cpkt.TargetActor, this.character, out this.character._target))
{
if (character.Target is Character)
{
Character Target = this.character.Target as Character;
if (Target.TradeSession != null)
{
//CHARACTER CAN'T TRADE, HE IS ALREADY IN A TRADE
SMSG_TRADERESULT spkt = new SMSG_TRADERESULT();
spkt.ActorId = cpkt.TargetActor;
spkt.SessionId = this.character.id;
spkt.Reason = (byte)TradeResult.TargetAlreadyInTrade;
this.Send((byte[])spkt);
}
else
{
//TRADE SESSION ESTABLISHED
TradeSession tradesession = new TradeSession(this.character, Target);
Target.TradeSession = tradesession;
this.character.TradeSession = tradesession;
//TRADE INVITATION WAIT FOR CONFIRMATION
SMSG_TRADEINVITATION spkt = new SMSG_TRADEINVITATION();
spkt.SessionId = Target.id;
spkt.ActorId = this.character.id;
Target.client.Send((byte[])spkt);
}
}
else
{
//SELECTED TARGET WAS NOT FOUND
SMSG_TRADERESULT spkt = new SMSG_TRADERESULT();
spkt.ActorId = cpkt.TargetActor;
spkt.SessionId = this.character.id;
spkt.Reason = (byte)TradeResult.TargetNotFound;
this.Send((byte[])spkt);
}
}
}
protected TradeSession findBest(System.Collections.Generic.List <TradeSession> sessions)
{
TradeSession bestSession = null;
double p = Double.MinValue;
double maxDrawDown = Double.MaxValue;
int hits = Int32.MinValue;
int trades = Int32.MinValue;
foreach (TradeSession s in sessions)
{
if (s.p > p)
{
p = s.p;
maxDrawDown = s.maxDrawDown;
bestSession = s;
trades = s.trades.Count;
}
}
return(bestSession);
}
/// <summary>
/// 保存会话信息，并更新该会话对应账号下面的TradeToken
/// </summary>
/// <param name="tradeToken"></param>
/// <param name="session">存储的交易账户信息，过期时间为0代表永久有效</param>
/// <returns></returns>
public bool SaveSession(string tradeToken, TradeSession session)
{
if (string.IsNullOrWhiteSpace(tradeToken))
{
return(false);
}
if (session == null || string.IsNullOrEmpty(session.BrokerAccount))
{
return(false);
}
var allToken = InnerGetAllToken(session.CompCounter, session.BrokerAccount);
if (allToken == null)
{
allToken = new List <string>();
}
allToken.Add(tradeToken);
this.distributedCache.Set(GetBrokerAccountKey(session.CompCounter, session.BrokerAccount), allToken);
return(UpdateSession(tradeToken, session));
}
void ProcessCurrentTrade()
{
if (CurrentTrade == null)
{
return;
}
CurrentTrade.Update();
TradeEvent @event = null;
while (CurrentTrade.Events.TryDequeue(out @event))
{
//Logger.WriteLine("Got event: " + evt.type);
HandleTradeEvent(CurrentTrade, @event);
}
if (CurrentTrade.Status != ETradeTransactionStatus.InProgress)
{
CurrentTrade = null;
}
}
public async Task TradeAsync(SocketUser user)
{
Context.TryGetUser(user.Id, out ArcadeUser account);
if (await CatchEmptyAccountAsync(account))
{
return;
}
if (!Context.Account.CanTrade)
{
return;
}
Context.Account.CanTrade = false;
var session = new TradeSession(Context, account);
await StartSessionAsync(session, TimeSpan.FromSeconds(20));
Context.Account.CanTrade = true;
account.CanTrade = true;
}
public void MaxNumberOfBuyOrdersHolder()
{
// arrange
var sessionWithZeroOrders = new TradeSession {
OpenOrders = new List <ExchangeOrder> ()
};
var sessionWithOneOrder = new TradeSession {
OpenOrders = new List <ExchangeOrder> {
new ExchangeOrder {
Type = BitstampOrderType.Buy
}
}
};
var sessionWithTwoOrders = new TradeSession
{
OpenOrders = new List <ExchangeOrder> {
new ExchangeOrder {
Type = BitstampOrderType.Buy
},
new ExchangeOrder {
Type = BitstampOrderType.Buy
}
}
};
var tradeHolder = new MaxNumberOfBuyOrdersHolder(2);
// act
var resultWithZeroOrders = tradeHolder.Execute(sessionWithZeroOrders);
var resultWithOneOrder = tradeHolder.Execute(sessionWithOneOrder);
var resultWithTwoOrders = tradeHolder.Execute(sessionWithTwoOrders);
// assert
Assert.AreEqual(resultWithZeroOrders, false);
Assert.AreEqual(resultWithOneOrder, false);
Assert.AreEqual(resultWithTwoOrders, true);
}
void HandleTradeTextCommand(TradeSession trade, TradeEvent @event)
{
SendChatDelegate sendDelegate = (sender, entry, text) =>
{
trade.SendChatMessage(text);
};
TradeCommand cmd;
if (!HandleCommandCommon(
@event.message, @event.sender, sendDelegate, out cmd))
{
return;
}
var messageMap = new Dictionary <TradeCommand, Action <string, TradeSession> >
{
{ TradeCommand.Help, HandleTradeHelpCommand },
{ TradeCommand.Ready, HandleTradeReadyCommand },
{ TradeCommand.Add, HandleTradeAddCommand },
{ TradeCommand.Remove, HandleTradeRemoveCommand },
{ TradeCommand.Confirm, HandleTradeConfirmCommand },
{ TradeCommand.Items, HandleTradeItemsCommand },
{ TradeCommand.Cancel, HandleTradeCancelCommand },
};
Action <string, TradeSession> func;
if (!messageMap.TryGetValue(cmd, out func))
{
Logger.WriteLine("Unhandled trade command: {0}", cmd);
return;
}
func(@event.message, trade);
}
public void WaitPeriodAfterBuyOrderHolder()
{
// arrange
var tradeSession1 = new TradeSession {
Timestamp = DateTime.Now, LastBuyTimestamp = DateTime.Now
};
var tradeSession2 = new TradeSession {
Timestamp = DateTime.Now, LastBuyTimestamp = DateTime.Now.AddSeconds(-30)
};
var tradeSession3 = new TradeSession {
Timestamp = DateTime.Now, LastBuyTimestamp = DateTime.Now.AddSeconds(-61)
};
var tradeHolder = new WaitPeriodAfterBuyOrderHolder(TimeSpan.FromMinutes(1));
// act
var result1 = tradeHolder.Execute(tradeSession1);
var result2 = tradeHolder.Execute(tradeSession2);
var result3 = tradeHolder.Execute(tradeSession3);
// assert
Assert.AreEqual(result1, true);
Assert.AreEqual(result2, true);
Assert.AreEqual(result3, false);
}
public void setTrade(TradeSession tradeSession)
{
this.tradeSession = tradeSession;
}
void HandleTradeCancelCommand(string msg, TradeSession trade)
{
trade.CancelTrade();
}
void HandleTradeConfirmCommand(string msg, TradeSession trade)
{
trade.Confirm();
}
public bool Execute(TradeSession tradeSession)
{
var openOrders = tradeSession.OpenOrders.Where(o => o.PairCode == tradeSession.PairCode).ToList();
return(openOrders.Count(o => o.Type == BitstampOrderType.Buy) >= _maxNumberOfBuyOrders);
}
protected void signalPerformanceOptimization(TA.PriceVolumeSeries series, double[] data, int windowSize,
double stopLoss,
int maxDays, double diffSell, double diffBuy, int days,
System.Collections.Generic.List<TradeSession> bestBlocks)
{
Trade trade;
System.Collections.Generic.List<Trade> trades = new System.Collections.Generic.List<Trade>(10);
int i = 0;
while (i < (data.Length - 1))
{
int idx = i + windowSize;
TA.Candle candle = (TA.Candle)series.Data[idx];
double p;
if (signalSell(series, idx, diffSell, days))
{
signalPerformance(series, stopLoss, maxDays, idx, false, diffSell, diffBuy, days, out trade);
if (trades.Count < 200) trades.Add(trade);
else break;
i += Math.Max(1, trade.days);
// System.Console.Write("\tSell at "+idx+" entry="+trade.entry+" exit="+trade.exit+" "+candle.ToString());
// System.Console.WriteLine(" p="+trade.p+", days="+trade.days+", exit at "+(idx+trade.days));
}
else if (signalBuy(series, idx, diffBuy, days)) // buy condition and trigger
{
signalPerformance(series, stopLoss, maxDays, idx, true, diffSell, diffBuy, days, out trade);
if (trades.Count < 200) trades.Add(trade);
else break;
i += Math.Max(1, trade.days);
// System.Console.Write("\tBuy at "+idx+" entry="+trade.entry+" exit="+trade.exit+" "+candle.ToString());
// System.Console.WriteLine(" p="+trade.p+", days="+trade.days+", exit at "+(idx+trade.days));
}
else i++;
}
double pTotal;
int daysTotal;
int hits;
double maxDrawDown;
signalPerformanceGetTrades(trades, out daysTotal, out hits, out pTotal, out maxDrawDown);
int misses = trades.Count - hits;
if ((pTotal > 1.1) && (trades.Count > 5) && (bestBlocks.Count < 1000))
{
TradeSession ts = new TradeSession();
ts.trades = trades;
ts.maxDays = maxDays;
ts.p = pTotal;
ts.days = daysTotal;
ts.hits = hits;
ts.stopLoss = stopLoss;
ts.sellSignal = diffSell;
ts.buySignal = diffBuy;
ts.maxDays = maxDays;
ts.maxDrawDown = maxDrawDown;
bestBlocks.Add(ts);
System.Console.Write("+");
// System.Console.WriteLine("p="+pTotal);
// signalPerformancePrintTrades(trades);
}
if ((pTotal > 2) && (trades.Count > 5) && (bestBlocks.Count > 1000))
System.Console.Write("-");
// System.Console.Write("1");
}
/// <summary>
/// Occurs when your aggreeing with the trade.
/// After the trade content has been agreed.
/// </summary>
private void CM_TRADECONFIRM(CMSG_TRADECONFIRM cpkt)
{
TradeSession session = this.character.TradeSession;
if (session != null)
{
//OBTAIN THE ORGIN TARGET
Character target;
TradeSession.TradeItem[] Items;
if (this.character.TradeSession.Source == this.character)
{
target = session.Target;
Items = session.TargetItem;
}
else
{
target = session.Source;
Items = session.SourceItem;
}
//Calculate required slots
int slots = 0;
for (int i = 0; i < 16; i++)
{
if (Items[i] == null)
{
continue;
}
slots++;
}
if (slots > this.character.container.Capacity - this.character.container.Count)
{
//Not enough space oponent
SMSG_TRADERESULT2 spkt = new SMSG_TRADERESULT2();
spkt.Reason = (byte)TradeResult.TargetNotEnoughInventorySpace;
spkt.SessionId = target.id;
target.client.Send((byte[])spkt);
//Not enough space myself
SMSG_TRADERESULT2 spkt2 = new SMSG_TRADERESULT2();
spkt2.Reason = (byte)TradeResult.NotEnoughIventorySpace;
spkt2.SessionId = this.character.id;
this.Send((byte[])spkt2);
//Set tradesession to null;
this.character.TradeSession = null;
target.TradeSession = null;
return;
}
else
{
if (session.Source == this.character)
{
session.SourceHasAgreed = true;
}
else
{
session.TargetHasAgreed = true;
}
}
if (session.TargetHasAgreed && session.SourceHasAgreed)
{
target.ZENY += session.ZenySource;
this.character.ZENY -= session.ZenySource;
target.ZENY -= session.ZenyTarget;
this.character.ZENY += session.ZenyTarget;
List <Rag2Item> SourceList = new List <Rag2Item>();
List <Rag2Item> TargetList = new List <Rag2Item>();
for (int i = 0; i < 16; i++)
{
TradeSession.TradeItem item = session.SourceItem[i];
if (item == null)
{
continue;
}
Rag2Item ragitem = this.character.container[item.Slot];
if (ragitem.count - item.Count == 0)
{
SourceList.Add(ragitem);
this.character.container.RemoveAt(item.Slot);
SMSG_DELETEITEM spkt = new SMSG_DELETEITEM();
spkt.Container = 2;
spkt.Index = item.Slot;
spkt.SessionId = this.character.id;
spkt.UpdateReason = (byte)ItemUpdateReason.SendToTrader;
this.Send((byte[])spkt);
}
else
{
SourceList.Add(ragitem.Clone(item.Count));
ragitem.count -= item.Count;
SMSG_UPDATEITEM spkt = new SMSG_UPDATEITEM();
spkt.Container = 2;
spkt.Index = item.Slot;
spkt.SessionId = this.character.id;
spkt.UpdateReason = (byte)ItemUpdateReason.SendToTrader;
spkt.UpdateType = 4;
this.Send((byte[])spkt);
}
}
for (int i = 0; i < 16; i++)
{
TradeSession.TradeItem item = session.TargetItem[i];
if (item == null)
{
continue;
}
Rag2Item ragitem = target.container[item.Slot];
if (ragitem.count - item.Count == 0)
{
TargetList.Add(ragitem);
this.character.container.RemoveAt(item.Slot);
SMSG_DELETEITEM spkt = new SMSG_DELETEITEM();
spkt.Container = 2;
spkt.Index = item.Slot;
spkt.SessionId = target.id;
spkt.UpdateReason = (byte)ItemUpdateReason.SendToTrader;
target.client.Send((byte[])spkt);
}
else
{
TargetList.Add(ragitem.Clone(item.Count));
ragitem.count -= item.Count;
SMSG_UPDATEITEM spkt = new SMSG_UPDATEITEM();
spkt.Container = 2;
spkt.Index = item.Slot;
spkt.SessionId = target.id;
spkt.UpdateReason = (byte)ItemUpdateReason.SendToTrader;
spkt.UpdateType = 4;
target.client.Send((byte[])spkt);
}
}
for (int i = 0; i < SourceList.Count; i++)
{
Rag2Item ragitem = SourceList[i];
int index = target.container.Add(ragitem);
SMSG_ADDITEM spkt = new SMSG_ADDITEM();
spkt.Container = 2;
spkt.UpdateReason = (byte)ItemUpdateReason.ReceiveFromTrade;
spkt.SessionId = target.id;
spkt.SetItem(ragitem, index);
target.client.Send((byte[])spkt);
}
for (int i = 0; i < TargetList.Count; i++)
{
Rag2Item ragitem = TargetList[i];
int index = this.character.container.Add(ragitem);
SMSG_ADDITEM spkt = new SMSG_ADDITEM();
spkt.Container = 2;
spkt.UpdateReason = (byte)ItemUpdateReason.ReceiveFromTrade;
spkt.SessionId = this.character.id;
spkt.SetItem(ragitem, index);
this.Send((byte[])spkt);
}
//Update zeny yourself
SMSG_SENDZENY spkt4 = new SMSG_SENDZENY();
spkt4.SessionId = this.character.id;
spkt4.Zeny = this.character.ZENY;
this.Send((byte[])spkt4);
//Update zeny opponent
SMSG_SENDZENY spkt5 = new SMSG_SENDZENY();
spkt5.SessionId = target.id;
spkt5.Zeny = target.ZENY;
target.client.Send((byte[])spkt5);
//Set traderesult to succesfull
SMSG_TRADERESULT2 spkt3 = new SMSG_TRADERESULT2();
spkt3.SessionId = this.character.id;
this.Send((byte[])spkt3);
//Set traderesult successfull oponent
SMSG_TRADERESULT2 spkt2 = new SMSG_TRADERESULT2();
spkt2.SessionId = target.id;
target.client.Send((byte[])spkt2);
//Set the tradesession to null
this.character.TradeSession = null;
target.TradeSession = null;
}
}
}
public static void PrepareVirtualTrade(Pawn pawn, VirtualTrader trader)
{
TradeSession.SetupWith(trader, pawn, false);
trader.InvokeTradeUI();
}
