public void OnDecidedEx(DecidedEx decided)
{
gameManager.viewModel.MainWindowDispatcher.Invoke(() =>
{
gameManager.SetDecisions(managerNum, decided);
});
// _decided = decided[0];
//gameManager.viewModel.MainWindowDispatcher.Invoke(decidedMethod);
}
public void SetDecisions(int index, DecidedEx decideds)
{
if (index == 0)
{
viewModel.Decisions1P = decideds.Data;
viewModel.Decisions1PSelectedIndex = 0;
}
else
{
viewModel.Decisions2P = decideds.Data;
viewModel.Decisions2PSelectedIndex = 0;
}
var decided = decideds[0];
Agent.Direction dir = Agent.CastPointToDir(new Point(decided.MeAgent1.X, decided.MeAgent1.Y));
OrderToAgent(new Order(index * 2, dir, Agent.State.MOVE));
dir = Agent.CastPointToDir(new Point(decided.MeAgent2.X, decided.MeAgent2.Y));
OrderToAgent(new Order(index * 2 + 1, dir, Agent.State.MOVE));
}
//1ターン = 深さ2
protected override void Solve()
{
for (int i = 0; i < 50; ++i)
{
dp1[i].Score = int.MinValue;
dp2[i].Score = int.MinValue;
}
int deepness = StartDepth;
int maxDepth = (TurnCount - CurrentTurn) * 2 + 2;
PointEvaluator.Base evaluator = (TurnCount / 3 * 2) < CurrentTurn ? PointEvaluator_Normal : PointEvaluator_Dispersion;
SearchState state = new SearchState(MyBoard, EnemyBoard, new Player(MyAgent1, MyAgent2), new Player(EnemyAgent1, EnemyAgent2), WaysPool);
int score = PointEvaluator_Normal.Calculate(ScoreBoard, state.MeBoard, 0) - PointEvaluator_Normal.Calculate(ScoreBoard, state.EnemyBoard, 0);
Log("TurnCount = {0}, CurrentTurn = {1}", TurnCount, CurrentTurn);
if (!(lastTurnDecided is null))
{
Log("IsAgent1Moved = {0}, IsAgent2Moved = {1}, lastTurnDecided = {2}", IsAgent1Moved, IsAgent2Moved, lastTurnDecided);
}
if (!(lastTurnDecided is null) && IsAgent1Moved == false && IsAgent2Moved == false && score > 0) //勝っている状態で競合していたら
{
SolverResultList.Add(lastTurnDecided);
return;
}
for (; deepness <= maxDepth; deepness++)
{
DecidedEx resultList = new DecidedEx();
int greedyDepth = Math.Min(greedyMaxDepth, maxDepth - deepness);
if ((deepness + greedyDepth) % 2 == 1 && greedyDepth > 0)
{
greedyDepth--;
}
//普通にNegaMaxをして、最善手を探す
NegaMax(deepness, state, int.MinValue + 1, int.MaxValue, 0, evaluator, null, greedyDepth);
Decided best1 = new Decided(dp1[0].Agent1Way, dp1[0].Agent2Way);
resultList.Add(best1);
//競合手.Agent1 == 最善手.Agent1 && 競合手.Agent2 == 最善手.Agent2になった場合、競合手をngMoveとして探索をおこない、最善手を探す
if ((IsAgent1Moved == false && lastTurnDecided.MeAgent1.Equals(best1.MeAgent1)) && (IsAgent2Moved == false && lastTurnDecided.MeAgent2.Equals(best1.MeAgent2)))
{
NegaMax(deepness, state, int.MinValue + 1, int.MaxValue, 0, evaluator, best1, greedyDepth);
Decided best2 = new Decided(dp2[0].Agent1Way, dp2[0].Agent2Way);
resultList.Add(best2);
}
if (CancellationToken.IsCancellationRequested == false)
{
SolverResultList = resultList;
if (SolverResultList.Count == 2 && score <= 0) //現時点で引き分けか負けていたら競合を避けるのを優先してみる（デバッグ用）
{
var tmp = SolverResultList[0];
SolverResultList[0] = SolverResultList[1];
SolverResultList[1] = tmp;
Log("[SOLVER] Swaped! {0} {1}", SolverResult.MeAgent1, SolverResult.MeAgent2);
}
Log("[SOLVER] SolverResultList.Count = {0}, score = {1}", SolverResultList.Count, score);
}
else
{
return;
}
Log("[SOLVER] deepness = {0}", deepness);
}
}