public void LongVTest()
{
var problem = new Problem { width = 6 };
var unit = new Unit
{
members = new HashSet<Cell>(new[]
{
new Cell { x = 0, y = 2 },
new Cell { x = 0, y = 3 },
new Cell { x = 1, y = 4 },
new Cell { x = 1, y = 3 },
new Cell { x = 2, y = 2 }
}),
pivot = new Cell { x = 1, y = 0 }
};
var placedUnit = Game.SpawnUnit(unit, problem);
var members = placedUnit.members.ToArray();
Assert.AreEqual(new Cell { x = 1, y = 0 }, members[0]);
Assert.AreEqual(new Cell { x = 1, y = 1 }, members[1]);
Assert.AreEqual(new Cell { x = 2, y = 2 }, members[2]);
Assert.AreEqual(new Cell { x = 2, y = 1 }, members[3]);
Assert.AreEqual(new Cell { x = 3, y = 0 }, members[4]);
Assert.AreEqual(new Cell { x = 2, y = -2 }, placedUnit.pivot);
}
public string Solve(Problem problem, int seed, string[] magicSpells)
{
var game = new ConsoleGame(problem, seed, magicSpells);
var emulator = new Emulator(game, -1);
emulator.Run();
var solution = game.Solution;
return solution;
}
public void SmallBacteriaTest()
{
var problem = new Problem { width = 10 };
var unit = new Unit { members = new HashSet<Cell>(new[] { new Cell { x = 1, y = 1 } }), pivot = new Cell { x = 2, y = 2 } };
var placedUnit = Game.SpawnUnit(unit, problem);
Assert.AreEqual(new Cell { x = 4, y = 0 }, placedUnit.members.Single());
Assert.AreEqual(new Cell { x = 4, y = 1 }, placedUnit.pivot);
}
public void SinglePointTest_5()
{
var problem = new Problem { width = 5 };
var unit = new Unit { members = new HashSet<Cell>(new[] { new Cell { x = 5, y = 5 } }), pivot = new Cell { x = 5, y = 5 } };
var placedUnit = Game.SpawnUnit(unit, problem);
Assert.AreEqual(new Cell { x = 2, y = 0 }, placedUnit.members.Single());
Assert.AreEqual(new Cell { x = 2, y = 0 }, placedUnit.pivot);
}
public static IProblemSolver SelectSolver(Problem problem)
{
//return new MuggleProblemSolver_MultiUnit(1);
//return new AStarProblemSolver();
return new MuggleProblemSolver_MultiUnit(1);
if(square <= 100)
return new MuggleProblemSolver_MultiUnit(2, 4);
if(square < 3000)
return new MuggleProblemSolver_MultiUnit(1);
return new MuggleProblemSolver_MultiUnit(0);*/
}
public Result CountScore(Problem problem, Func<IProblemSolver> solverFactory, string[] powerPhrases, string folder)
{
long sum = 0;
var lockerForLists = new object();
List<Output> outputs = new List<Output>();
List<GameBase.State> states = new List<GameBase.State>();
List<int> scores = new List<int>();
Parallel.For(0, problem.sourceSeeds.Length, new ParallelOptions() { MaxDegreeOfParallelism = Math.Max(1, Environment.ProcessorCount - 2) }, seedInd =>
{
var solver = solverFactory();
var seed = problem.sourceSeeds[seedInd];
try
{
Console.WriteLine("Problem {0}: seed {1} started counting", problem.id, seed);
var stopwatch = Stopwatch.StartNew();
var solution = solver.Solve(problem, seed, powerPhrases);
stopwatch.Stop();
var output = new Output() { problemId = problem.id, seed = seed, solution = solution };
var game = new Game(problem, output, powerPhrases);
while (game.state == GameBase.State.UnitInGame || game.state == GameBase.State.WaitUnit)
{
game.Step();
}
lock (lockerForLists)
{
scores.Add(game.CurrentScore);
states.Add(game.state);
outputs.Add(output);
}
Console.WriteLine("Problem {0}: seed: {1}, score: {2}, time: {3}", problem.id, seed, game.CurrentScore,
stopwatch.Elapsed);
SaveOutput(folder + problem.id, output);
}
catch (Exception ex)
{
Console.WriteLine("Problem {0}: seed {1} crashed {2}", problem.id, seed, ex.Message);
throw;
}
});
var result = new Result { Outputs = outputs.ToArray(), EndStates = states.ToArray(), Scores = scores.ToArray() };
SaveResult(folder + problem.id, result);
return result;
}
public string Solve(Problem problem, int seed, string[] powerPhrases)
{
var finalPowerPhraseBuilder = new SimplePowerPhraseBuilder(powerPhrases);
var spelledPhrases = new bool[powerPhrases.Length];
var solution = new List<MoveType>();
var game = new SolverGame(problem, seed, powerPhrases);
while (true)
{
switch (game.state)
{
case GameBase.State.WaitUnit:
game.Step();
break;
case GameBase.State.UnitInGame:
var reachablePositions = new ReachablePositionsWithWords(game.map, powerPhrases, spelledPhrases);
var evaluatePositions = new EvaluatePositions2(game.map);
var endPositions = reachablePositions.EndPositions(game.currentUnit);
var estimated = new Dictionary<Unit, double>();
var bestPosition = endPositions.ArgMax(p =>
{
double value;
if (estimated.TryGetValue(p.Item1, out value))
return value;
return estimated[p.Item1] = evaluatePositions.Evaluate(p.Item1);
});
var score = evaluatePositions.Evaluate(bestPosition.Item1);
var wayToBestPosition = bestPosition.Item2;
var unitSolution = staticPowerPhraseBuilder.Build(wayToBestPosition.path);
SolutionAdded(game, unitSolution);
game.ApplyUnitSolution(unitSolution);
spelledPhrases = wayToBestPosition.spelledWords;
solution.AddRange(wayToBestPosition.path);
break;
case GameBase.State.EndInvalidCommand:
case GameBase.State.EndPositionRepeated:
throw new InvalidOperationException(string.Format("Invalid state: {0}", game.state));
case GameBase.State.End:
return finalPowerPhraseBuilder.Build(solution);
default:
throw new ArgumentOutOfRangeException();
}
}
}
public override string Solve(Problem problem, int seed, string[] powerPhrases)
{
var finalPowerPhraseBuilder = new SimplePowerPhraseBuilder(powerPhrases);
var spelledPhrases = new bool[powerPhrases.Length];
var solution = new List<MoveType>();
var game = new SolverGame(problem, seed, powerPhrases);
while (true)
{
switch (game.state)
{
case GameBase.State.WaitUnit:
game.Step();
break;
case GameBase.State.UnitInGame:
if (nextUnitsPositions == null || !nextUnitsPositions.Any())
{
var bestPositions = FindBestPositions_Recursive(unitsAhead, game.map.Clone(),
new[] { game.currentUnit }.Concat(game.GetAllRestUnits()).ToArray(), 0, powerPhrases, spelledPhrases);
nextUnitsPositions = bestPositions.Item2.ToList();
}
var wayToBestPosition = nextUnitsPositions.First();
nextUnitsPositions = nextUnitsPositions.Skip(1).ToList();
var unitSolution = staticPowerPhraseBuilder.Build(wayToBestPosition.Item2.path);
CallEvent(game, unitSolution);
game.ApplyUnitSolution(unitSolution);
solution.AddRange(wayToBestPosition.Item2.path);
spelledPhrases = wayToBestPosition.Item2.spelledWords;
break;
case GameBase.State.EndInvalidCommand:
case GameBase.State.EndPositionRepeated:
throw new InvalidOperationException(string.Format("Invalid state: {0}", game.state));
case GameBase.State.End:
return finalPowerPhraseBuilder.Build(solution);
default:
throw new ArgumentOutOfRangeException();
}
}
}
public GameBase([NotNull] Problem problem, int seed, string[] knownMagicSpells)
{
this.problem = problem;
this.seed = seed;
this.knownMagicSpells = knownMagicSpells.Select(s => s.ToLower()).ToArray();
ReStart();
}
public GameBase([NotNull] Problem problem, int seed, string[] knownMagicSpells)
{
this.problem = problem;
this.seed = seed;
this.knownMagicSpells = knownMagicSpells.Select(s => s.ToLower()).ToArray();
units = problem.units;
UnitIndeces = new int[problem.sourceLength];
var randomGenerator = new LinearCongruentalGenerator(seed);
for (int i = 0; i < problem.sourceLength; i++)
UnitIndeces[i] = randomGenerator.GetNext() % units.Length;
ReStart();
}
public ConsoleGame(Problem problem, int seed, string[] magicSpells)
: base(problem, seed, magicSpells)
{
}
public string Solve(Problem problem, int seed, string[] magicSpells)
{
return magicSpells[0];
}