private void GetBasicInfo(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo)
{
IOIDSettingDTO SelectedSetting;
IList <Action <IList <string>, string, object> > MappingHandlers;
//Get setting of interest
SelectedSetting = OIDSettings["DeviceBasicInfo"];
//Define handle collection in order
MappingHandlers = new List <Action <IList <string>, string, object> >();
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).Description = y; });
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).OIDobjectID = y; });
MappingHandlers.Add(null);
MappingHandlers.Add(null);
MappingHandlers.Add((x, y, z) =>
{
EnumDeviceType dvt;
IDeviceTopologyInfoDTO Data = (IDeviceTopologyInfoDTO)z;
Data.DeviceName = y;
Data.DeviceType = Enum.TryParse <EnumDeviceType>(Regex.Match(y, @"^.*?(?=[0-9])").ToString(), out dvt) ? dvt : EnumDeviceType.Unknown;
});
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).Location = y; });
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).OSIImplementedLayers = (EnumOSILayers)Enum.Parse(typeof(EnumOSILayers), y); });
//Add network known data
TopologyInfo.DeviceIPAndMask = $"{Device.TargetIP}/{Device.NetworkMask}";
if (RegardingObject.ARPTable.Any(x => x.Value == $"{Device.TargetIP}"))
{
TopologyInfo.DeviceMAC = RegardingObject.ARPTable.Where(x => x.Value == $"{Device.TargetIP}").First().Key;
}
//Collect data mapping with handlers
StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers);
}
public IDictionary <string, IDictionary <DateTime, decimal> > GetCurrentRates(IList <string> rates)
{
IDictionary <string, IDictionary <DateTime, decimal> > historyData = new Dictionary <string, IDictionary <DateTime, decimal> >();
try
{
IList <RateRecord> rts = RateProvider.Instance.GetRates();
foreach (string rate in rates)
{
var hd = new Dictionary <DateTime, decimal>();
var record = rts.Where(item => item.Name == rate).FirstOrDefault();
if (record == null)
{
continue;
}
StrategyHelper.CloseCandle(_candles, record, CANDLES_INTERVAL_MINUTES);
hd.Add(record.UpdateTime, record.Value);
historyData.Add(rate, hd);
}
}
catch (Exception ex)
{
SendMessageEvent(ex.Message);
}
return(historyData);
}
public void DeleteSytrategyAssemblyFromSavedDirectoryTest()
{
bool deleted = true;
//var folderName =
// StrategyHelper.GetStrategyFileName(
// @"~\..\..\..\..\TradeHub.StrategyEngine.Testing.SimpleStrategy\bin\Debug\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll");
var folderName = "TradeHub.StrategyEngine.Testing.SimpleStrategy";
StrategyHelper.RemoveAssembly(folderName);
var allStrategyNames = StrategyHelper.GetAllStrategiesName();
foreach (string strategyName in allStrategyNames)
{
if (strategyName.Equals("TradeHub.StrategyEngine.Testing.SimpleStrategy"))
{
deleted = false;
break;
}
}
Assert.IsTrue(deleted);
}
/// <summary>
/// Finds parameters to be used for optimization for the given Strategy and displays on UI
/// </summary>
private void OptimizationParameterDetails()
{
// Clear existing data
OptimizationParameters.Clear();
// Contains custom defined attributes in the given assembly
Dictionary <int, Tuple <string, Type> > customAttributes = null;
// Get Custom Attributes
if (_selectedStrategy.StrategyType != null)
{
// Get custom attributes from the given assembly
customAttributes = StrategyHelper.GetCustomAttributes(_selectedStrategy.StrategyType);
foreach (KeyValuePair <int, Tuple <string, Type> > keyValuePair in customAttributes)
{
var parameter = new OptimizationParameterDetail();
parameter.Index = keyValuePair.Key;
parameter.Description = keyValuePair.Value.Item1;
parameter.ParameterType = keyValuePair.Value.Item2;
// Add to observable collection to display on UI
OptimizationParameters.Add(parameter);
}
}
}
public void GetStrategyPathTest()
{
_dir1 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1");
string path = StrategyHelper.GetStrategyPath("Strategy1");
Assert.AreEqual(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1\\Strategy1.dll", path);
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="strategyType"></param>
/// <param name="ctorArguments"></param>
public TestStrategyExecutor(Type strategyType, object[] ctorArguments)
{
// Initialize parameters
//TestStrategyInitializeParameters(strategyType,ctorArguments);
_manualReset = new ManualResetEvent(false);
_asyncClassLogger = new AsyncClassLogger("TestStrategyExecutor");
// Save Strategy Type
_strategyType = strategyType;
//Save Arguments
_ctorArguments = ctorArguments;
// Set Logging levels
_asyncClassLogger.SetLoggingLevel();
// Get new strategy instance
var strategyInstance = StrategyHelper.CreateStrategyInstance(_strategyType, _ctorArguments);
if (strategyInstance != null)
{
// Cast to TradeHubStrategy Instance
TradeHubStrategy = strategyInstance as TradeHubStrategy;
InitializeStrategyListeners();
OverrideMarketRequestCalls();
OverrideOrderRequestCalls();
}
}
/// <summary>
/// Gets all possible combinations for the given parameters
/// </summary>
/// <param name="args">ctor arguments to create combinations with</param>
/// <param name="conditionalParameters">contains info for the conditional parameters</param>
/// <param name="conditionalIndex">index of conditional parameter to be used for iterations</param>
private void GetAllIterations(object[] args, Tuple <int, string, string>[] conditionalParameters, int conditionalIndex)
{
try
{
// get index of parameter to be incremented
int index = conditionalParameters[conditionalIndex].Item1;
// Get end value for the parameter
decimal endPoint;
if (!decimal.TryParse(conditionalParameters[conditionalIndex].Item2, out endPoint))
{
return;
}
// Get increment value to be used
decimal increment;
if (!decimal.TryParse(conditionalParameters[conditionalIndex].Item3, out increment))
{
return;
}
// Get Orignal Value
decimal orignalValue = Convert.ToDecimal(args[index]);
// Iterate through all combinations
for (decimal i = 0; ; i += increment)
{
// Modify parameter value
var parameter = orignalValue + i;
if (parameter > endPoint)
{
break;
}
// Convert string value to required format
var value = StrategyHelper.GetParametereValue(parameter.ToString(), _parmatersDetails[index].ParameterType.Name);
// Update arguments array
args[index] = value;
// Check if the combination is already present
if (!ValueAdded(args, _ctorArguments, index))
{
// Add the updated arguments to local map
_ctorArguments.Add(args.Clone() as object[]);
// Get further iterations if
if (conditionalIndex > 0)
{
GetAllIterations(args.Clone() as object[], conditionalParameters, conditionalIndex - 1);
}
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
/// <summary>
/// Initializes necessary fields and parameters
/// </summary>
/// <param name="strategyType">User Strategy Type</param>
/// <param name="ctorArguments">Constructor arguments to initialize strategy</param>
private void Initialize(Type strategyType, object[] ctorArguments)
{
_manualReset = new ManualResetEvent(false);
_logger = new AsyncClassLogger("StrategyExecutorGeneticAlgo");
_logger.SetLoggingLevel();
// Save Strategy Type
_strategyType = strategyType;
//Save Arguments
_ctorArguments = ctorArguments;
// Set Logging levels
_logger.SetLoggingLevel();
// Get new strategy instance
var strategyInstance = StrategyHelper.CreateStrategyInstance(_strategyType, _ctorArguments);
if (strategyInstance != null)
{
// Cast to TradeHubStrategy Instance
_tradeHubStrategy = strategyInstance as TradeHubStrategy;
InitializeStrategyListeners();
OverrideMarketRequestCalls();
OverrideOrderRequestCalls();
}
}
public void GetAllStrategiesPathTest()
{
_dir1 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1");
var strategiesPaths = StrategyHelper.GetAllStrategiesPath();
Assert.AreEqual(1, strategiesPaths.Count);
Assert.AreEqual(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1\\Strategy1.dll", strategiesPaths[0]);
}
public double Calculate(int firstNumber, int secondNumber, Operator operatorEnum)
{
var calculationExpression = $"{firstNumber}{operatorEnum}{secondNumber}";
var calculationStrategy = StrategyHelper.GetMatchingStrategy(calculationExpression);
var result = calculationStrategy.GetCalculationResult();
return(result);
}
public void InvalidAssemblyVerificationTest()
{
string assemblyPath =
Path.GetFullPath(
@"~\..\..\..\..\TradeHub.StrategyEngine.Testing.SimpleStrategy\bin\Debug\TradeHub.Common.Core.dll");
Assert.IsFalse(StrategyHelper.ValidateStrategy(assemblyPath));
}
public void Start()
{
var number = new Number(int.MaxValue, int.MaxValue);
var helper = new StrategyHelper();
logger.Info($"{number.NumberOne} + {number.NumberTwo} = {helper.DoStrategy(new Context(new Add()), number)}");
logger.Info($"{number.NumberOne} - {number.NumberTwo} = {helper.DoStrategy(new Context(new Substract()), number)}");
logger.Info($"{number.NumberOne} * {number.NumberTwo} = {helper.DoStrategy(new Context(new Multiply()), number)}");
}
public void GetAllStrategiesNameTest()
{
_dir1 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy1");
_dir2 = Directory.CreateDirectory(DirectoryStructure.STRATEGY_LOCATION + "\\Strategy2");
List <string> strategies = StrategyHelper.GetAllStrategiesName();
Assert.AreEqual(2, strategies.Count);
Assert.AreEqual("Strategy1", strategies[0]);
Assert.AreEqual("Strategy2", strategies[1]);
}
public void CalculateMovingVolatility()
{
// Arrange
var deviationsSquared = new double[] { 0, 4, 25, 4, 9, 25, 0, 1, 16, 4, 16, 0, 9, 25, 4, 9, 9, 4, 1, 4, 9 };
// Act
var volatility = StrategyHelper.CalculateMovingVolatility(20, deviationsSquared, 20);
// Assert
Assert.AreEqual(Math.Round(volatility, 3), 3.061);
}
public int GetFibonacci(int n)
{
bool baseCase = n == 0 || n == 1;
if (baseCase)
{
return(n);
}
return(StrategyHelper.FailIfCheckedAdditionFails(GetFibonacci(n - 1), GetFibonacci(n - 2)));
}
public void GetConstructorDetails_LoadAssembly_ReturnInfo_Successfull()
{
string assemblyPath =
Path.GetFullPath(
@"~\..\..\..\..\TradeHub.StrategyEngine.Testing.SimpleStrategy\bin\Release\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll");
// Get Class Type from assembly
var details = StrategyHelper.GetConstructorDetails(assemblyPath);
Assert.AreEqual(details.Item2.Count(), 9, "Parameter Count");
}
private void LACPAssignmentMapper(IList <string> IndexValues, string Value, object StrategyDTOobject)
{
IDictionary <string, IList <string> > LACPMapping = StrategyDTOobject as IDictionary <string, IList <string> >;
LACPMapping.Add(IndexValues[0], new List <string>());
string[] positions = StrategyHelper.GetFlagArrayPositions(Value);
for (int i = 0; i < positions.Length; i++)
{
LACPMapping[IndexValues[0]].Add(positions[i]);
}
}
public void TestThatStrategyIsExecutingAndChangingItsStatus()
{
string assemblyPath =
Path.GetFullPath(@"~\..\..\..\..\Lib\testing\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll");
Assert.True(File.Exists(assemblyPath));
var classtype = StrategyHelper.GetStrategyClassType(assemblyPath);
var parametersDetails = StrategyHelper.GetParameterDetails(classtype);
Dictionary <string, ParameterDetail> parameters = new Dictionary <string, ParameterDetail>();
parameters.Add("1", new ParameterDetail(typeof(int), 10));
parameters.Add("2", new ParameterDetail(typeof(int), 15));
parameters.Add("3", new ParameterDetail(typeof(string), "LAST"));
parameters.Add("4", new ParameterDetail(typeof(string), "ERX"));
parameters.Add("5", new ParameterDetail(typeof(decimal), 1000));
parameters.Add("6", new ParameterDetail(typeof(string), BarFormat.TIME));
parameters.Add("7", new ParameterDetail(typeof(string), BarPriceType.LAST));
parameters.Add("8", new ParameterDetail(typeof(string), TradeHubConstats.MarketDataProvider.SimulatedExchange));
parameters.Add("9", new ParameterDetail(typeof(string), TradeHubConstats.OrderExecutionProvider.SimulatedExchange));
object[] paramters =
{
(int)10, (int)15, (string)"LAST", (string)"ERX", (decimal)1000, BarFormat.TIME, BarPriceType.LAST,
TradeHubConstats.MarketDataProvider.SimulatedExchange, TradeHubConstats.OrderExecutionProvider.SimulatedExchange
};
var instance = StrategyHelper.CreateStrategyInstance(classtype, paramters);
StrategyInstance strategyInstance = new StrategyInstance();
strategyInstance.InstanceKey = "A00";
strategyInstance.Parameters = parameters;
strategyInstance.StrategyType = classtype;
strategyInstance.Symbol = "ERX";
StrategyController controller = new StrategyController();
StrategyStatusRepresentation statusRepresentationrepresentation = null;
ManualResetEvent resetEvent = new ManualResetEvent(false);
controller.StrategyStatusChanged += delegate(StrategyStatusRepresentation representation)
{
statusRepresentationrepresentation = representation;
resetEvent.Set();
};
controller.AddStrategyInstance(strategyInstance);
resetEvent.WaitOne(5000);
controller.RunStrategy(strategyInstance.InstanceKey);
resetEvent.WaitOne(2000);
Assert.NotNull(statusRepresentationrepresentation);
Assert.AreEqual(StrategyStatus.Executing, statusRepresentationrepresentation.StrategyStatus);
}
/// <summary>
/// Get all saved strategies
/// </summary>
/// <returns></returns>
public List <Strategy> GetAllStrategies()
{
List <Strategy> savedStrategies = new List <Strategy>();
//get all saved strategies
var strategies = StrategyHelper.GetAllStrategiesName();
//cast all strategies names to its object
foreach (var strategy in strategies)
{
//savedStrategies.Add(new Strategy(){Key = strategy});
}
return(savedStrategies);
}
/// <summary>
/// Returns IList of actual parameter values from the Parameter Details object
/// </summary>
/// <returns></returns>
public IList <object> GetParameterValues(Dictionary <string, ParameterDetail> parameterDetails)
{
IList <object> parameterValues = new List <object>();
// Traverse all parameter
foreach (KeyValuePair <string, ParameterDetail> keyValuePair in parameterDetails)
{
// Makes sure all parameters are in right format
var input = StrategyHelper.GetParametereValue(keyValuePair.Value.ParameterValue.ToString(), keyValuePair.Value.ParameterType.Name);
// Add actual parameter values to the new object list
parameterValues.Add(input);
}
return(parameterValues);
}
/// <summary>
/// 运行策略，并且将策略运行结果绑定到该
/// </summary>
public void Run()
{
if (this.strategyData == null || this.strategyData.Strategy == null)
{
return;
}
IStrategy strategy = this.strategyData.Strategy;
StrategyReferedPeriods referedPeriods = strategy.GetReferedPeriods();
if (referedPeriods == null)
{
referedPeriods = new StrategyReferedPeriods();
KLinePeriod currentPeriod = this.compChart.Controller.ChartComponentData.KlinePeriod;
referedPeriods.UsedKLinePeriods.Add(currentPeriod);
if (strategy is StrategyAbstract)
{
((StrategyAbstract)strategy).MainKLinePeriod = currentPeriod;
}
}
KLinePeriod mainPeriod = referedPeriods.MainPeriod;
StrategyForwardPeriod forwardPeriod = new StrategyForwardPeriod(referedPeriods.UseTickData, mainPeriod);
IStrategyExecutorFactory executorFactory = StrategyCenter.Default.GetStrategyExecutorFactory();
IDataPackage_Code dataPackage = this.compChart.Controller.CurrentNavigater.DataPackage;
Dictionary <KLinePeriod, int> dic_KLinePeriod_StartPos = new Dictionary <KLinePeriod, int>();
for (int i = 0; i < referedPeriods.UsedKLinePeriods.Count; i++)
{
KLinePeriod period = referedPeriods.UsedKLinePeriods[i];
dic_KLinePeriod_StartPos.Add(period, dataPackage.GetKLineData(period).BarPos);
}
drawOperator = new ChartComponentStrategyDrawer(this.compChart.Drawer, dic_KLinePeriod_StartPos, 0, 0);
StrategyArguments_DataPackage strategyDataPackage = new StrategyArguments_DataPackage(dataPackage, referedPeriods, forwardPeriod);;
StrategyHelper strategyOperator = new StrategyHelper();
strategyOperator.Drawer = drawOperator;
strategyExecutor = executorFactory.CreateExecutor_History(strategyDataPackage);
strategyExecutor.Strategy = strategy;
//strategyExecutor.Run();
//strategyExecutor.ExecuteFinished += StrategyExecutor_ExecuteFinished;
strategyExecutor.Execute();
}
private void GetLearnedMACAddresses(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo)
{
IOIDSettingDTO SelectedSetting;
IList <Action <IList <string>, string, object> > MappingHandlers;
//Get setting of interest
SelectedSetting = OIDSettings["LearnedMACByPhysPortID"];
//Define handle collection in order
MappingHandlers = new List <Action <IList <string>, string, object> >();
MappingHandlers.Add(LearnedAddressMapper);
//Initialize container if necesary
TopologyInfo.PortLearnedAddresses = new Dictionary <string, IDictionary <string, string> >();
//Collect data mapping with handlers
StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers);
}
protected override void OnStrategyStart()
{
StrategyHelper = new StrategyHelper(framework, this);
StrategyHelper.OpenCloseHelper = new OpenCloseHelper(framework, this);
//StrategyHelper.PriceHelper = new PriceHelper(framework, 0.001);
//StrategyHelper.TimeHelper = new TimeHelper(Instrument.Symbol);
//StrategyHelper.MarketOrderType = SmartQuant.OrderType.Limit;
//StrategyHelper.Tick = 10;
StrategyHelper.OpenCloseHelper.SeparateOrder = SeparateOrder.SeparateCloseOpen;
StrategyHelper.OpenCloseHelper.DefaultClose = DefaultClose.CloseToday;
StrategyHelper.OpenCloseHelper.SendStyle = SendStyle.OneByOne;
//StrategyHelper.EnableTrading = true;
//StrategyHelper.EnableLongEntry = true;
//StrategyHelper.EnableShortEntry = true;
}
private void GetPortMACAddress(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo)
{
IOIDSettingDTO SelectedSetting;
IList <Action <IList <string>, string, object> > MappingHandlers;
//Get setting of interest
SelectedSetting = OIDSettings["PhysPortMACAddress"];
//Define handle collection in order
MappingHandlers = new List <Action <IList <string>, string, object> >();
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).PortMACAddress.Add(x[0], y); });
//Define container if necesary
TopologyInfo.PortMACAddress = new Dictionary <string, string>();
//Collect data mapping with handlers
StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers);
}
/// <summary>
/// Returns IList of actual parameter values from the Parameter Details object
/// </summary>
/// <returns></returns>
public object[] GetParameterValues()
{
int entryCount = 0;
object[] parameterValues = new object[Parameters.Count];
// Traverse all parameter
foreach (KeyValuePair <string, ParameterDetail> keyValuePair in Parameters)
{
// Makes sure all parameters are in right format
var input = StrategyHelper.GetParametereValue(keyValuePair.Value.ParameterValue.ToString(), keyValuePair.Value.ParameterType.Name);
// Add actual parameter values to the new object list
parameterValues[entryCount++] = input;
}
return(parameterValues);
}
/// <summary>
/// Returns Initial Parameter values
/// </summary>
/// <returns></returns>
public object[] GetParameterValues()
{
int entryCount = 0;
object[] parameterValues = new object[ParameterDetails.Count];
// Traverse all parameter
foreach (BruteForceParameterDetail iteratorVariable in ParameterDetails)
{
// Makes sure all parameters are in right format
var input = StrategyHelper.GetParametereValue(iteratorVariable.ParameterValue.ToString(), iteratorVariable.ParameterType.Name);
// Add actual parameter values to the new object list
parameterValues[entryCount++] = input;
}
return(parameterValues);
}
/// <summary>
/// Loads and Initializes "TradeHub" strategy from the given assembly
/// </summary>
/// <param name="path">Assembly path</param>
public void LoadAssembly(string path)
{
try
{
// Load Assembly file from the selected file
Assembly assembly = Assembly.LoadFrom(path);
var strategyDetails = StrategyHelper.GetConstructorDetails(path);
if (strategyDetails == null)
{
Console.WriteLine("NULL value in strategy details");
return;
}
// Get Strategy Type
_strategyType = strategyDetails.Item1;
//// Verify Strategy Instance
//if (_tradeHubStrategy == null)
//{
// // Get new strategy instance
// var strategyInstance = LoadCustomStrategy.CreateStrategyInstance(_strategyType, _ctorArguments);
// if (strategyInstance != null)
// {
// // Cast to TradeHubStrategy Instance
// _tradeHubStrategy = strategyInstance as TradeHubStrategy;
// }
// if (_tradeHubStrategy == null)
// {
// Console.WriteLine("Unable to initialize Custom Strategy: " + _strategyType.FullName);
// // Skip execution of further actions
// return;
// }
//}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
private void GetAggregateDestinations(ISNMPDeviceDataDTO Device, IDictionary <string, IOIDSettingDTO> OIDSettings, IDeviceTopologyInfoDTO TopologyInfo)
{
IOIDSettingDTO SelectedSetting;
IList <Action <IList <string>, string, object> > MappingHandlers;
//Get setting of interest
SelectedSetting = OIDSettings["TrunkDestinationsCDP"];
//Define handle collection in order
MappingHandlers = new List <Action <IList <string>, string, object> >();
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).PortAggregateDestinations.Add(x[0], new CustomPair <string, string>(y, null)); });
MappingHandlers.Add((x, y, z) => { ((IDeviceTopologyInfoDTO)z).PortAggregateDestinations[x[0]].Second = y; });
//Define container if necesary
TopologyInfo.PortAggregateDestinations = new Dictionary <string, CustomPair <string, string> >();
//Collect data mapping with handlers
StrategyHelper.OIDEntryProcessor(Device, TopologyInfo, SelectedSetting, MappingHandlers);
}
/// <summary>
/// Verify and add strategy to TradeHub
/// </summary>
/// <param name="assemblyPath"></param>
/// <returns></returns>
public bool VerifyAndAddStrategy(string assemblyPath)
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Received call for adding strategy, path=" + assemblyPath, _type.FullName, "VerifyAndAddStrategy");
}
if (StrategyHelper.ValidateStrategy(assemblyPath))
{
StrategyHelper.CopyAssembly(assemblyPath);
if (Logger.IsInfoEnabled)
{
Logger.Info("Strategy Added", _type.FullName, "VerifyAndAddStrategy");
}
return(true);
}
return(false);
}
private Sbr FindBestResponse(StrategyHelper strHelper, int pos, GameDefinition gd,
Sbr.CreateRootGenNodeDelegate createRootGenNodeDelegate)
{
Sbr br = new Sbr();
br.GameDef = gd;
br.HeroPosition = pos;
if (createRootGenNodeDelegate != null)
{
br.CreateRootGenNode = createRootGenNodeDelegate;
}
strHelper.SetProbabilityOfOppAction();
br.SetOppStrategy(1 - pos, strHelper.OppStrategy.ToArray());
br.Calculate();
return(br);
}
