// Use this for initialization
void Start()
{
flagCtrl = transform.GetChild(0);
strCtrl = GameObject.FindWithTag("StrategyController").GetComponent <StrategyController>();
pathfinding = GameObject.FindWithTag("Pathfinding").GetComponent <MyPathfinding>();
cityFlagsCtrl = GameObject.FindWithTag("CityFlags").GetComponent <FlagsController>();
}
protected override Task CheckStrategies()
{
// TODO: Check registered strategies.
StrategyController strategyController = new StrategyController();
Dictionary <string, double> prevPrice = new Dictionary <string, double>();
var reutberg = new Reutberg.ReutbergService();
foreach (var strategy in strategyController.getStrategies())
{
string ticker = strategy.Value.Ticker;
double newQuote = (double)reutberg.GetQuote(ticker);
if (!prevPrice.ContainsKey(ticker))
{
prevPrice[ticker] = newQuote;
}
else
if ((newQuote / prevPrice[ticker]) == ((100.0 + (double)strategy.Value.PriceMovement) / 100.0))
{
if (strategy.Value.Instruction == BuySell.Buy)
{
reutberg.Buy(ticker, strategy.Value.Quantity);
strategyController.UnregisterStrategy(strategy.Key);
}
else
if (strategy.Value.Instruction == BuySell.Sell)
{
reutberg.Sell(ticker, strategy.Value.Quantity);
strategyController.UnregisterStrategy(strategy.Key);
}
}
}
return(Task.CompletedTask);
}
public override void StartStrategy(StrategyController <SoldierAntData> controller)
{
base.StartStrategy(controller);
//待機状態に戻ってきたときにすぐ応答する用
PeriodicUpdate();
}
public override void StartStrategy(StrategyController <BuilderAntData> controller)
{
base.StartStrategy(controller);
Debug.Log($"<MoveStrategy> start ant: {Controller.Ant.transform.position.ToString()} distNode:{_distNode.WorldPosition.ToString()} distHost:{_distNode.Host.transform.position}");
Controller.Ant.StartForPathNode(_distNode, HandleArrived, HandleAborted);
}
public override void StartStrategy(StrategyController <SoldierAntData> controller)
{
base.StartStrategy(controller);
//攻撃間隔
UpdateInterval = GetAntCommonData <SoldierAntCommonData>().CombatInterval;
}
// Use this for initialization
void Start()
{
sc = GameObject.Find("Synchronize Manager").GetComponent <StrategyController>();
strategy = sc.strategy;
trans = this.gameObject.GetComponent <NetworkTransform>();
ResetStrategy();
}
public override void StartStrategy(StrategyController <EnemyAntData> controller)
{
base.StartStrategy(controller);
UpdateInterval = 1.0f;
_targetNode = GetTargetPathNode();
Controller.Ant.StartForPathNode(_targetNode, HandleArrived, HandleAborted);
}
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);
}
public void RegisterStrategyTest2()
{
StrategyDetailsDto strategyDetails = new StrategyDetailsDto();
strategyDetails.Instruction = TradingPlaces.Resources.BuySell.Sell;
strategyDetails.PriceMovement = 2;
strategyDetails.Quantity = 10;
strategyDetails.Ticker = "MSBT";
StrategyController strategyController = new StrategyController();
var result = strategyController.RegisterStrategy(strategyDetails);
var okResult = result as OkObjectResult;
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
}
public void UnregisterStrategyTest2()
{
StrategyDetailsDto strategyDetails = new StrategyDetailsDto();
strategyDetails.Instruction = TradingPlaces.Resources.BuySell.Sell;
strategyDetails.PriceMovement = 2;
strategyDetails.Quantity = 10;
strategyDetails.Ticker = "MSBT";
StrategyController strategyController = new StrategyController();
var mockDependency = new Mock <StrategyController>();
CreatedResult result = new CreatedResult("12345678", strategyDetails);
mockDependency.Setup(x => x.RegisterStrategy(strategyDetails)).Returns(result);
string id = "12345678";
var result2 = strategyController.UnregisterStrategy(id);
var okResult = result2 as OkObjectResult;
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
}
private void InitializeTick(Player me, World world, Game game, Move move)
{
Me = me;
World = world;
Game = game;
Action = move;
_turnsPer60Ticks = _turnsPer60TicksMin + 3 * world.Facilities.Count(f => f.OwnerPlayerId == Me.Id && f.Type == FacilityType.ControlCenter);
if (TurnAfterLast60Tick.Any() && TurnAfterLast60Tick.Peek() <= World.TickIndex - 60)
{
TurnAfterLast60Tick.Dequeue();
}
foreach (Vehicle vehicle in World.NewVehicles)
{
VehicleById[vehicle.Id] = vehicle;
UpdateTickByVehicleId[vehicle.Id] = world.TickIndex;
}
foreach (VehicleUpdate vehicleUpdate in world.VehicleUpdates)
{
long vehicleId = vehicleUpdate.Id;
if (vehicleUpdate.Durability == 0)
{
VehicleById.Remove(vehicleId);
UpdateTickByVehicleId.Remove(vehicleId);
}
else
{
VehicleById[vehicleId] = new Vehicle(VehicleById[vehicleId], vehicleUpdate);
UpdateTickByVehicleId[vehicleId] = world.TickIndex;
}
}
InitStrategy();
if (World.TickIndex % 16 == 0)
{
IndicatorFacillites.Update(World.Facilities);
GameGrid.Update(EnemyVehicles, World.Facilities);
}
if ((World.TickIndex + 64) % 512 == 0)
{
foreach (var squad in GroupManager.Squads.Where(s => s.Id >= (int)Group.NewGroup))
{
StrategyController.FindSingleEnemy(squad);
}
}
UpDateDelayedTasks();
if (Me.RemainingNuclearStrikeCooldownTicks <= 0)
{
if (World.TickIndex % 2 == 0)
{
if (!EnemyVehicles.Any() || !MyVehicles.Any())
{
return;
}
foreach (var cell in GameGrid.Grid)
{
if (cell.EnemyCount > 5)
{
foreach (var squad in GroupManager.Squads)
{
if (cell.Distance(squad) < 200)
{
var enemies = EnemyVehicles.Where(v =>
v.X > cell.X * 64 && v.X <(cell.X + 1) * 64 && v.Y> cell.Y * 64 &&
v.Y < (cell.Y + 1) * 64 && v.Type != VehicleType.Arrv).ToList();
if (!enemies.Any())
{
continue;
}
var enemyCenter = enemies.CenterXY();
var navodchick = MyVehicles.FirstOrDefault(v => v.Durability > 90 && v.VisionRange * 0.8 > v.GetDistanceTo(enemyCenter.X, enemyCenter.Y));
if (navodchick != null)
{
MainGameTasks.Enqueue(Act.Nuclear(new MyPoint(enemyCenter.X, enemyCenter.Y), navodchick.Id));
}
}
}
}
}
}
}
}
// Update is called once per frame
void Update()
{
if (!isQuitConfirmMode)
{
if (Misc.GetBack())
{
gameObject.SetActive(false);
strCtrl.ReturnMainMode();
return;
}
if (Input.GetMouseButtonUp(0))
{
Vector3 mousePoint = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2 point = new Vector2(mousePoint.x, mousePoint.y);
Rect bound = bgSprite.boundingRect;
bound.x += transform.position.x;
bound.y += transform.position.y;
if (!bound.Contains(point))
{
gameObject.SetActive(false);
Input.ResetInputAxes();
strCtrl.ReturnMainMode();
return;
}
}
for (int i = 0; i < 4; i++)
{
if (commands[i].GetButtonState() == Button.ButtonState.Clicked)
{
if (i == 3)
{
isQuitConfirmMode = true;
confirmBox.SetActive(true);
Vector3 pos = commands[i].transform.position;
if (pos.x + 100 + 128 < 320)
{
confirmBox.transform.position = new Vector3(pos.x + 100 + 64, pos.y + 10, confirmBox.transform.position.z);
}
else
{
confirmBox.transform.position = new Vector3(pos.x - 100 - 64, pos.y + 10, confirmBox.transform.position.z);
}
}
else
{
commandAct[i].SetActive(true);
gameObject.SetActive(false);
}
}
}
}
else
{
if (Misc.GetBack())
{
isQuitConfirmMode = false;
confirmBox.SetActive(false);
return;
}
if (okBtn.GetButtonState() == Button.ButtonState.Clicked)
{
Controller.historyTime = 190;
HistoryTimeController.Reset();
StrategyController.Reset();
Informations.Instance.armys.Clear();
Application.LoadLevel(0);
GameObject.Destroy(GameObject.Find("MouseTrack"));
}
else if (cancelBtn.GetButtonState() == Button.ButtonState.Clicked)
{
isQuitConfirmMode = false;
confirmBox.SetActive(false);
}
}
}
public override void StartStrategy(StrategyController <EnemyAntData> controller)
{
base.StartStrategy(controller);
UpdateInterval = GetAntCommonData <EnemyAntCommonData>().CombatInterval;
}
