public BacktestSession CreateSession(Guid accountId, TickerType tickerType, BarItemType barType, string barDataFile, Guid cacheId)
{
if (backtestSessions == null)
{
backtestSessions = new Dictionary <Guid, BacktestSession>();
}
this.cacheId = cacheId;
//this line should raise an exception if file is invalid
BarItemFile.ValidateFile(barDataFile);
BacktestSession backtestSession = new BacktestSession(accountId, tickerType, barDataFile, cacheId);
//backtestSession.SignalClosePosition += OnSignalClosePosition;
//backtestSession.SignalOpenPosition += OnSignalOpenPosition;
backtestSession.StrategyClosePosition += OnStrategyClosePosition;
backtestSession.StrategyOpenPosition += OnStrategyOpenPosition;
backtestSessions.Add(backtestSession.SessionId, backtestSession);
brokerAccounts[accountId].Orders.Initialize(barType, backtestSession.SessionId);
return(backtestSession);
}
public static void TickPostfix(TickList __instance)
{
int currentTickInterval = __instance.TickInterval;
TickerType currentTickType = __instance.tickType;
switch (currentTickType)
{
case TickerType.Normal:
RimThreaded.thingListNormal = __instance.thingLists[Find.TickManager.TicksGame % currentTickInterval];
RimThreaded.thingListNormalTicks = RimThreaded.thingListNormal.Count;
break;
case TickerType.Rare:
RimThreaded.thingListRare = __instance.thingLists[Find.TickManager.TicksGame % currentTickInterval];
RimThreaded.thingListRareTicks = RimThreaded.thingListRare.Count;
break;
case TickerType.Long:
RimThreaded.thingListLong = __instance.thingLists[Find.TickManager.TicksGame % currentTickInterval];
RimThreaded.thingListLongTicks = RimThreaded.thingListLong.Count;
break;
case TickerType.Never:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static void RequireTicker(this ThingComp comp, TickerType type)
{
if (comp.parent.def.tickerType != type)
{
RemoteTechController.Instance.Logger.Error($"{comp.GetType().Name} requires tickerType:{type} in def {comp.parent.def.defName}");
}
}
public static void RequireTicker(this ThingComp comp, TickerType type)
{
if (comp.parent.def.tickerType != type)
{
Log.Error($"{comp.GetType().Name} requires tickerType:{type} in def {comp.parent.def.defName}");
}
}
public SignalCharting(ISignalChart chartControl, TickerType tickerType, BarItemType barType, object dataStreamSource)
{
this.dataStreamSource = dataStreamSource;
this.tickerType = tickerType;
this.barType = barType;
this.chartControl = chartControl;
this.registeredAnalytics = new List <AnalyticsItem>();
SharedCacheFactory.Instance.CacheWriter = new FileCacheWriter("cache");
SharedCacheFactory.Instance.CacheReader = new FileCacheReader("cache");
if (dataStreamSource is string)
{
FileInfo file = new FileInfo(dataStreamSource.ToString());
long fileHash = file.Attributes.GetHashCode() ^ file.CreationTime.Ticks ^ file.LastWriteTime.Ticks ^ file.Length;
CacheConfig cacheConfig = new CacheConfig("cache");
cacheConfig.Initialize();
cacheConfig.Open(CachingModeOption.Reading);
CacheRow row = cacheConfig.Read(fileHash);
cacheConfig.Close();
if (row == null)
{
cacheConfig.Open(CachingModeOption.Writing);
cacheId = Guid.NewGuid();
cacheConfig.Append(fileHash, cacheId, SessionModeOption.Backtesting);
cacheConfig.Close();
}
else
{
cacheId = new Guid((byte[])row["SessionId"]);
}
}
}
public static void Postfix(TickerType ___tickType)
{
if (___tickType == TickerType.Long)
{
BaseOverlay.SetDirty(typeof(TreeGrowthOverlay));
}
}
static bool Prefix(Thing t)
{
if (Multiplayer.Client == null || t.Map == null)
{
return(true);
}
MapAsyncTimeComp comp = t.Map.AsyncTime();
TickerType tickerType = t.def.tickerType;
if (tickerType == TickerType.Normal)
{
comp.tickListNormal.RegisterThing(t);
}
else if (tickerType == TickerType.Rare)
{
comp.tickListRare.RegisterThing(t);
}
else if (tickerType == TickerType.Long)
{
comp.tickListLong.RegisterThing(t);
}
return(false);
}
public static void Postfix(TickerType ___tickType)
{
if (___tickType == TickerType.Long)
{
BaseOverlay.SetDirty(typeof(PlantHarvestOverlay));
}
}
public BackgroundSignal(TickerType tickerType, BarItemType barType, object dataStreamSource)
{
this.dataStreamSource = dataStreamSource;
this.tickerType = tickerType;
this.barType = barType;
this.registeredAnalytics = new List <AnalyticsItem>();
}
public void RegisterToTickManager(ThingWithComps thing)
{
TickerType tickerType = thing.def.tickerType;
if (tickerType == TickerType.Rare)
{
return; // already done
}
if (tickerType == TickerType.Normal)
{
return; // faster than what we like, but we'll manage
}
if (tickerType == TickerType.Long) // not supported
// If we get anything like this, we might want to know about it eventually. We could force in
// CompTickLong support via Harmony patch.
{
Log.Error(
"Unable to register " + thing + " to TickManager. Using this kind of LootAffixModifier is " +
"(currently) unsupported for ThingDefs with tickerType=Long (like " + thing.def + ")."
);
return;
}
// Manipulating TickLists outside of ThingDef.tickerType requires private list access
// [Reflection] TickManager.tickListRare.RegisterThing(thing)
FieldInfo tickListRareField = AccessTools.Field(typeof(TickManager), "tickListRare");
TickList tickListRare = (TickList)tickListRareField.GetValue(Find.TickManager);
tickListRare.RegisterThing(thing);
}
public void CloseLastOrder(DateTime time, TickerType tickerType, double bidPrice, double askPrice, BarItem barItem)
{
MarketOrder marketOrder = marketOrders[lastTickerOrder[tickerType.Symbol]];
marketOrder.CloseOrder(time, bidPrice, askPrice, barItem.Time);
marketOrderCache.AppendMarketOrder(marketOrders.Count, marketOrder.Position, marketOrder.OrderTime, marketOrder.OpeningBarTime, marketOrder.OpeningBidPrice, marketOrder.OpeningAskPrice,
barItem.Time, marketOrder.ClosingBarTime, marketOrder.ClosingBidPrice, marketOrder.ClosingAskPrice);
}
public TickList(TickerType tickType)
{
this.tickType = tickType;
for (int i = 0; i < this.TickInterval; i++)
{
this.thingLists.Add(new List <Thing>());
}
}
public string GetTicker(TickerType tickerType)
{
string streamAddress = null;
string ticker = string.Format("ticker.{0}", tickerType);
if (data.ContainsKey(ticker))
streamAddress = data[ticker];
return streamAddress;
}
public static bool Tick(TickList __instance)
{
currentTickType = tickType(__instance);
currentTickInterval = get_TickInterval(__instance);
List <Thing> tr = thingsToRegister(__instance);
for (int index = 0; index < tr.Count; ++index)
{
Thing i = tr[index];
List <Thing> b = BucketOf(__instance, i);
b.Add(i);
}
tr.Clear();
List <Thing> td = thingsToDeregister(__instance);
for (int index = 0; index < td.Count; ++index)
{
Thing i = td[index];
List <Thing> b = BucketOf(__instance, i);
b.Remove(i);
}
td.Clear();
if (DebugSettings.fastEcology)
{
Find.World.tileTemperatures.ClearCaches();
for (int index1 = 0; index1 < thingLists(__instance).Count; ++index1)
{
List <Thing> thingList = thingLists(__instance)[index1];
for (int index2 = 0; index2 < thingList.Count; ++index2)
{
if (thingList[index2].def.category == ThingCategory.Plant)
{
thingList[index2].TickLong();
}
}
}
}
thingList1 = thingLists(__instance)[Find.TickManager.TicksGame % currentTickInterval];
thingQueue = new ConcurrentQueue <Thing>(thingList1);
CreateTickThreads();
foreach (EventWaitHandle eventWaitHandle in eventWaitStarts.Values)
{
eventWaitHandle.Set();
}
monitorThreadWaitHandle.Set();
MainThreadWaitLoop();
return(false);
}
public int GetTotalWinningOrders(TickerType tickerType)
{
int winningOrders = 0;
foreach (MarketOrder marketOrder in marketOrders.Values)
{
if (marketOrder.ProfitOrLossInPips > 0)
{
winningOrders++;
}
}
return(winningOrders);
}
public double GetTotalLoss(TickerType tickerType)
{
double loss = 0;
foreach (MarketOrder marketOrder in marketOrders.Values)
{
if (marketOrder.Ticker.Symbol == tickerType.Symbol)
{
loss += marketOrder.LossInPips;
}
}
return(loss);
}
public int GetTotalBreakevenOrders(TickerType tickerType)
{
int breakevenOrders = 0;
foreach (MarketOrder marketOrder in marketOrders.Values)
{
if (marketOrder.ProfitOrLossInPips == 0)
{
breakevenOrders++;
}
}
return(breakevenOrders);
}
public double GetTotalProfit(TickerType tickerType)
{
double profit = 0;
foreach (MarketOrder marketOrder in marketOrders.Values)
{
if (marketOrder.Ticker.Symbol == tickerType.Symbol)
{
profit += marketOrder.ProfitInPips;
}
}
return(profit);
}
public int GetTotalLosingOrders(TickerType tickerType)
{
int losingOrders = 0;
foreach (MarketOrder marketOrder in marketOrders.Values)
{
if (marketOrder.ProfitOrLossInPips < 0)
{
losingOrders++;
}
}
return(losingOrders);
}
public BacktestSession(Guid accountId, TickerType tickerType, string barDataFile, Guid cacheId, bool cachingEnabled = true)
{
this.accountId = accountId;
this.tickerType = tickerType;
this.barDataFile = barDataFile;
this.sessionId = Guid.NewGuid();
indicators = new SessionIndicators();
signals = new SessionSignals(indicators, cacheId, cachingEnabled);
signals.EntrySignal += OnEntrySignal;
signals.ExitSignal += OnExitSignal;
//strategies = new SessionStrategies(signals, indicators, cacheId, cachingEnabled);
//strategies.EntryPosition += OnEntryStrategy;
//strategies.ExitPosition += OnExitStrategy;
this.cacheId = cacheId;
this.cachingEnabled = cachingEnabled;
}
private static int TickInterval(TickerType type)
{
switch (type)
{
case TickerType.Normal:
return(1);
case TickerType.Rare:
return(250);
case TickerType.Long:
return(2000);
default:
return(-1);
}
}
public TCTickList(TickList old) : base(GetTickType(old))
{
tickType = GetTickType(old);
FieldInfo tl = AccessTools.Field(typeof(TickList), "thingLists");
thingLists = tl.GetValue(this) as List <List <Thing> >;
FieldInfo ttr = AccessTools.Field(typeof(TickList), "thingsToRegister");
thingsToRegister = ttr.GetValue(this) as List <Thing>;
FieldInfo ttd = AccessTools.Field(typeof(TickList), "thingsToDeregister");
thingsToDeregister = ttd.GetValue(this) as List <Thing>;
for (int i = 0; i < this.TickInterval; i++)
{
this.normalThingList.Add(new List <Thing>());
this.adjustedthingList.Add(new List <Thing>());
}
}
public Guid CreateMarketOrder(DateTime time, TickerType tickerType, MarketOrderState orderState, double bidPrice, double askPrice, BarItem barItem)
{
Guid marketOrderId = Guid.NewGuid();
MarketOrder marketOrder = new MarketOrder(tickerType);
marketOrder.OpenOrder(time, orderState, bidPrice, askPrice, barItem.Time);
marketOrders.Add(marketOrderId, marketOrder);
if (lastTickerOrder.ContainsKey(tickerType.Symbol))
{
lastTickerOrder[tickerType.Symbol] = marketOrderId;
}
else
{
lastTickerOrder.Add(tickerType.Symbol, marketOrderId);
}
return(marketOrderId);
}
private static bool Prefix(TickList __instance)
{
if (!Active)
{
return(true);
}
for (int i = 0; i < __instance.thingsToRegister.Count; i++)
{
__instance.BucketOf(__instance.thingsToRegister[i]).Add(__instance.thingsToRegister[i]);
}
__instance.thingsToRegister.Clear();
for (int j = 0; j < __instance.thingsToDeregister.Count; j++)
{
__instance.BucketOf(__instance.thingsToDeregister[j]).Remove(__instance.thingsToDeregister[j]);
}
__instance.thingsToDeregister.Clear();
if (DebugSettings.fastEcology)
{
Find.World.tileTemperatures.ClearCaches();
for (int k = 0; k < __instance.thingLists.Count; k++)
{
System.Collections.Generic.List <Thing> list = __instance.thingLists[k];
for (int l = 0; l < list.Count; l++)
{
if (list[l].def.category == ThingCategory.Plant)
{
list[l].TickLong();
}
}
}
}
System.Collections.Generic.List <Thing> list2 = __instance.thingLists[Find.TickManager.TicksGame % __instance.TickInterval];
for (int m = 0; m < list2.Count; m++)
{
Thing sam = list2[m];
if (!sam.Destroyed)
{
try
{
TickerType tickerType = __instance.tickType;
if (tickerType != TickerType.Normal)
{
if (tickerType != TickerType.Rare)
{
if (tickerType == TickerType.Long)
{
LogMe(sam, sam.TickLong, "TickLong");
}
}
else
{
LogMe(sam, sam.TickRare, "TickRare");
}
}
else
{
LogMe(sam, sam.Tick, "Tick");
}
}
catch (Exception ex)
{
string text = !list2[m].Spawned ? string.Empty : " (at " + list2[m].Position + ")";
if (Prefs.DevMode)
{
Log.Error(string.Concat("Exception ticking ", list2[m].ToStringSafe(), text, ": ", ex));
}
else
{
Log.ErrorOnce(
string.Concat("Exception ticking ", list2[m].ToStringSafe(), text,
". Suppressing further errors. Exception: ", ex),
list2[m].thingIDNumber ^ 576876901);
}
}
}
}
return(false);
}
public TickerType getTickerType(String name)
{
TickerType result = new TickerType();
switch (name)
{
case "avg":
result = TickerType.Avg;
break;
case "high":
result = TickerType.High;
break;
case "low":
result = TickerType.Low;
break;
case "vwap":
result = TickerType.Vwap;
break;
case "last_all":
result = TickerType.Last_all;
break;
case "last_local":
result = TickerType.Last_local;
break;
case "last_orig":
result = TickerType.Last_orig;
break;
case "last":
result = TickerType.Last;
break;
case "buy":
result = TickerType.Buy;
break;
case "sell":
result = TickerType.Sell;
break;
case "vol":
result = TickerType.Vol;
break;
}
return result;
}
public static bool Tick(TickList __instance)
{
TickerType currentTickType = tickType(__instance);
int currentTickInterval = get_TickInterval2(__instance);
Thing i;
List <Thing> tr = thingsToRegister(__instance);
for (int index = 0; index < tr.Count; ++index)
{
try
{
i = tr[index];
} catch (ArgumentOutOfRangeException) { break; }
List <Thing> b = BucketOf2(__instance, i, currentTickInterval);
b.Add(i);
}
lock (tr)
{
tr.Clear();
}
List <Thing> td = thingsToDeregister(__instance);
for (int index = 0; index < td.Count; ++index)
{
try
{
i = td[index];
} catch (ArgumentOutOfRangeException) { break; }
List <Thing> b = BucketOf2(__instance, i, currentTickInterval);
b.Remove(i);
}
lock (td)
{
td.Clear();
}
if (DebugSettings.fastEcology)
{
Find.World.tileTemperatures.ClearCaches();
for (int index1 = 0; index1 < thingLists(__instance).Count; ++index1)
{
List <Thing> thingList = thingLists(__instance)[index1];
for (int index2 = 0; index2 < thingList.Count; ++index2)
{
if (thingList[index2].def.category == ThingCategory.Plant)
{
thingList[index2].TickLong();
}
}
}
}
switch (currentTickType)
{
case TickerType.Normal:
RimThreaded.thingListNormal = thingLists(__instance)[Find.TickManager.TicksGame % currentTickInterval];
RimThreaded.thingListNormalTicks = RimThreaded.thingListNormal.Count;
break;
case TickerType.Rare:
RimThreaded.thingListRare = thingLists(__instance)[Find.TickManager.TicksGame % currentTickInterval];
RimThreaded.thingListRareTicks = RimThreaded.thingListRare.Count;
break;
case TickerType.Long:
RimThreaded.thingListLong = thingLists(__instance)[Find.TickManager.TicksGame % currentTickInterval];
RimThreaded.thingListLongTicks = RimThreaded.thingListLong.Count;
break;
}
return(false);
}
public void Tick()
{
for (int i = 0; i < this.thingsToRegister.Count; i++)
{
this.BucketOf(this.thingsToRegister[i]).Add(this.thingsToRegister[i]);
}
this.thingsToRegister.Clear();
for (int j = 0; j < this.thingsToDeregister.Count; j++)
{
this.BucketOf(this.thingsToDeregister[j]).Remove(this.thingsToDeregister[j]);
}
this.thingsToDeregister.Clear();
if (DebugSettings.fastEcology)
{
Find.World.tileTemperatures.ClearCaches();
for (int k = 0; k < this.thingLists.Count; k++)
{
List <Thing> list = this.thingLists[k];
for (int l = 0; l < list.Count; l++)
{
if (list[l].def.category == ThingCategory.Plant)
{
list[l].TickLong();
}
}
}
}
List <Thing> list2 = this.thingLists[Find.TickManager.TicksGame % this.TickInterval];
for (int m = 0; m < list2.Count; m++)
{
if (!list2[m].Destroyed)
{
try
{
TickerType tickerType = this.tickType;
if (tickerType != TickerType.Normal)
{
if (tickerType != TickerType.Rare)
{
if (tickerType == TickerType.Long)
{
list2[m].TickLong();
}
}
else
{
list2[m].TickRare();
}
}
else
{
list2[m].Tick();
}
}
catch (Exception ex)
{
string text = (!list2[m].Spawned) ? string.Empty : (" (at " + list2[m].Position + ")");
if (Prefs.DevMode)
{
Log.Error(string.Concat(new object[]
{
"Exception ticking ",
list2[m].ToStringSafe <Thing>(),
text,
": ",
ex
}), false);
}
else
{
Log.ErrorOnce(string.Concat(new object[]
{
"Exception ticking ",
list2[m].ToStringSafe <Thing>(),
text,
". Suppressing further errors. Exception: ",
ex
}), list2[m].thingIDNumber ^ 576876901, false);
}
}
}
}
}
private void OnSignalClosePosition(Guid accountId, TickerType tickerType, double bidPrice, double askPrice, BarItem barItem)
{
brokerAccounts[accountId].Orders.CloseLastOrder(DateTime.Now, tickerType, bidPrice, askPrice, barItem);
}
private void OnSignalOpenPosition(Guid accountId, TickerType tickerType, MarketOrderState position, double bidPrice, double askPrice, BarItem barItem)
{
brokerAccounts[accountId].Orders.CreateMarketOrder(DateTime.Now, tickerType, position, bidPrice, askPrice, barItem);
}
public void Tick()
{
for (int i = 0; i < this.thingsToRegister.Count; i++)
{
this.BucketOf(this.thingsToRegister[i]).Add(this.thingsToRegister[i]);
}
this.thingsToRegister.Clear();
for (int j = 0; j < this.thingsToDeregister.Count; j++)
{
this.BucketOf(this.thingsToDeregister[j]).Remove(this.thingsToDeregister[j]);
}
this.thingsToDeregister.Clear();
if (DebugSettings.fastEcology)
{
Find.World.tileTemperatures.ClearCaches();
for (int k = 0; k < this.thingLists.Count; k++)
{
List <Thing> list = this.thingLists[k];
for (int l = 0; l < list.Count; l++)
{
if (list[l].def.category == ThingCategory.Plant)
{
list[l].TickLong();
}
}
}
}
List <Thing> list2 = this.thingLists[Find.TickManager.TicksGame % this.TickInterval];
for (int m = 0; m < list2.Count; m++)
{
if (!list2[m].Destroyed)
{
try
{
TickerType tickerType = this.tickType;
if (tickerType != TickerType.Normal)
{
if (tickerType != TickerType.Rare)
{
if (tickerType == TickerType.Long)
{
list2[m].TickLong();
}
}
else
{
list2[m].TickRare();
}
}
else
{
list2[m].Tick();
}
}
catch (Exception ex)
{
if (Prefs.DevMode)
{
Log.Error("Exception ticking " + list2[m].ToString() + ": " + ex.ToString());
}
}
}
}
}
private void OnStrategyOpenPosition(Guid accountId, TickerType tickerType, PositionMode position, double bidPrice, double askPrice, BarItem barItem)
{
MarketOrderState marketOrderState = (MarketOrderState)Enum.Parse(typeof(MarketOrderState), Enum.GetName(typeof(PositionMode), position));
brokerAccounts[accountId].Orders.CreateMarketOrder(DateTime.Now, tickerType, marketOrderState, bidPrice, askPrice, barItem);
}
public double GetTotalLoss(Guid accountId, TickerType tickerType)
{
return(brokerAccounts[accountId].Orders.GetTotalLoss(tickerType));
}
