private void Move(ScratchRover rover)
{
if (PreviousX.Count > 4)
{
PreviousX.RemoveAt(PreviousX.Count - 1);
}
PreviousX.Insert(0, PosX);
if (PreviousY.Count > 4)
{
PreviousY.RemoveAt(PreviousY.Count - 1);
}
PreviousY.Insert(0, PosY);
if (moveDir == Direction.Up)
{
PosY -= 1; // Reversed for Scratch
}
else if (moveDir == Direction.Right)
{
PosX += 1;
}
else if (moveDir == Direction.Down)
{
PosY += 1; // Reversed for scratch
}
else
{
PosX -= 1;
}
rover.Move(moveDir);
}
private void SenseAdjacentSquares(ScratchRover rover)
{
_mapDirty = false;
_adjacentSquares.Clear();
rover.SenseSquare(Direction.Up);
if (_mappedTerrain[(_posY - 1) * Width + _posX] != rover.Sense) // Reversed for Scratch
{
_mapDirty = true;
}
_mappedTerrain[(_posY - 1) * Width + _posX] = rover.Sense; // Reversed for Scratch
_adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.Right);
if (_mappedTerrain[_posY * Width + _posX + 1] != rover.Sense)
{
_mapDirty = true;
}
_mappedTerrain[_posY * Width + _posX + 1] = rover.Sense;
_adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.Down);
if (_mappedTerrain[(_posY + 1) * Width + _posX] != rover.Sense) // Reversed for Scratch
{
_mapDirty = true;
}
_mappedTerrain[(_posY + 1) * Width + _posX] = rover.Sense; // Reversed for Scratch
_adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.Left);
if (_mappedTerrain[_posY * Width + _posX - 1] != rover.Sense)
{
_mapDirty = true;
}
_mappedTerrain[_posY * Width + _posX - 1] = rover.Sense;
_adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.None);
_mappedTerrain[_posY * Width + _posX] = rover.Sense;
_adjacentSquares.Add(rover.Sense);
_potentialPower[0] = 0;
_potentialPower[1] = 0;
if (_adjacentSquares[4] == TerrainType.Smooth)
{
_potentialPower[0] = rover.NoBacktrack * rover.NoBacktrack * rover.NoBacktrack;
}
for (Int32 i = 0; i < 4; i++)
{
if (_adjacentSquares[i] == TerrainType.Smooth)
{
_potentialPower[1] = (rover.NoBacktrack + 1) * (rover.NoBacktrack + 1) * (rover.NoBacktrack + 1);
break;
}
}
}
public void Simulate(ScratchRover rover)
{
while (true)
{
if (Step(rover))
{
break;
}
}
}
private void SenseAdjacentSquares(ScratchRover rover)
{
adjacentSquares.Clear();
rover.SenseSquare(Direction.Up);
adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.Right);
adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.Down);
adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.Left);
adjacentSquares.Add(rover.Sense);
rover.SenseSquare(Direction.None);
adjacentSquares.Add(rover.Sense);
}
private void Move(ScratchRover rover)
{
if (_moveDir == Direction.Up)
{
if (_adjacentSquares[0] != TerrainType.Impassable)
{
_posY -= 1; // Reversed for Scratch
}
else
{
throw new InvalidOperationException();
}
}
else if (_moveDir == Direction.Right)
{
if (_adjacentSquares[1] != TerrainType.Impassable)
{
_posX += 1;
}
else
{
throw new InvalidOperationException();
}
}
else if (_moveDir == Direction.Down)
{
if (_adjacentSquares[2] != TerrainType.Impassable)
{
_posY += 1; // Reversed for scratch
}
else
{
throw new InvalidOperationException();
}
}
else if (_moveDir == Direction.Left)
{
if (_adjacentSquares[3] != TerrainType.Impassable)
{
_posX -= 1;
}
else
{
throw new InvalidOperationException();
}
}
rover.Move(_moveDir);
}
public Boolean Step(ScratchRover rover)
{
if (rover == null)
{
throw new ArgumentNullException(nameof(rover));
}
if (rover.CollectSample())
{
return(true);
}
if (rover.ProcessSamples())
{
return(true);
}
if (rover.Transmit())
{
return(true);
}
Int32 num = _random.Next(0, 4);
if (num == 0)
{
rover.Move(Direction.Up);
}
else if (num == 1)
{
rover.Move(Direction.Right);
}
else if (num == 2)
{
rover.Move(Direction.Down);
}
else if (num == 3)
{
rover.Move(Direction.Left);
}
if (rover.IsHalted)
{
return(true);
}
return(rover.CollectPower());
}
public IEnumerable <RoverAction> Simulate(ScratchRover rover)
{
while (true)
{
yield return(RoverAction.CollectSample);
yield return(RoverAction.ProcessSamples);
yield return(RoverAction.Transmit);
Int32 num = _random.Next(0, 4);
if (num == 0)
{
yield return(new RoverAction(Direction.Up));
}
else if (num == 1)
{
yield return(new RoverAction(Direction.Right));
}
else if (num == 2)
{
yield return(new RoverAction(Direction.Down));
}
else if (num == 3)
{
yield return(new RoverAction(Direction.Left));
}
if (rover.IsHalted)
{
yield break;
}
yield return(RoverAction.CollectPower);
}
}
public IEnumerable <RoverAction> Simulate(ScratchRover rover)
{
while (true)
{
Direction smoothSquare = Direction.None;
SenseAdjacentSquares(rover);
for (Int32 i = 0; i < Direction.DirectionCount; i++)
{
if (adjacentSquares[i] == TerrainType.Smooth)
{
smoothSquare = (Direction)i;
break;
}
}
if (rover.Power < 30 || (smoothSquare == Direction.None && adjacentSquares[4] == TerrainType.Smooth))
{
if (rover.Power < 51 * rover.MovesLeft)
{
yield return(RoverAction.CollectPower);
}
}
if (rover.MovesLeft < 3)
{
if (rover.MovesLeft == 2)
{
yield return(RoverAction.ProcessSamples);
yield return(RoverAction.Transmit);
yield break;
}
yield return(RoverAction.Transmit);
}
if (rover.Power < 41)
{
if (rover.Power > 10)
{
yield return(RoverAction.CollectPower);
}
if (rover.Power < 41)
{
yield return(RoverAction.Transmit);
}
}
if (adjacentSquares[4] == TerrainType.Smooth || adjacentSquares[4] == TerrainType.Rough)
{
yield return(RoverAction.CollectSample);
if (rover.SamplesCollected >= 3)
{
yield return(RoverAction.ProcessSamples);
}
}
if (adjacentSquares.Contains(TerrainType.Smooth))
{
if (adjacentSquares[0] == TerrainType.Smooth)
{
yield return(new RoverAction(Direction.Up));
}
else if (adjacentSquares[1] == TerrainType.Smooth)
{
yield return(new RoverAction(Direction.Right));
}
else if (adjacentSquares[2] == TerrainType.Smooth)
{
yield return(new RoverAction(Direction.Down));
}
else if (adjacentSquares[3] == TerrainType.Smooth)
{
yield return(new RoverAction(Direction.Left));
}
}
else
{
Int32 num = _random.Next(0, 4);
if (num == 0)
{
yield return(new RoverAction(Direction.Up));
}
else if (num == 1)
{
yield return(new RoverAction(Direction.Right));
}
else if (num == 2)
{
yield return(new RoverAction(Direction.Down));
}
else if (num == 3)
{
yield return(new RoverAction(Direction.Left));
}
}
}
}
IEnumerable <RoverAction> IAi.Simulate(IRoverStatusAccessor rover)
{
var scratchRover = new ScratchRover(rover);
return(Ai.Simulate(scratchRover));
}
public void Simulate(IRoverStatusAccessor rover)
{
var scratchRover = new ScratchRover(rover);
Ai.Simulate(scratchRover);
}
public IEnumerable <RoverAction> Simulate(ScratchRover rover)
{
while (true)
{
Direction SmoothSquare = Direction.None;
SenseAdjacentSquares(rover);
for (Int32 i = 0; i < 5; i++)
{
if (adjacentSquares[i] == TerrainType.Smooth)
{
SmoothSquare = (Direction)i;
break;
}
}
if (rover.Power < 30 || (SmoothSquare == Direction.None && adjacentSquares[4] == TerrainType.Smooth))
{
if (rover.Power / rover.MovesLeft < 51)
{
yield return(RoverAction.CollectPower);
}
}
if (rover.MovesLeft < 3)
{
if (rover.MovesLeft == 2)
{
yield return(RoverAction.ProcessSamples);
}
yield return(RoverAction.Transmit);
}
if (rover.Power < 41)
{
if (rover.Power > 10)
{
yield return(RoverAction.CollectPower);
}
if (rover.Power < 41)
{
yield return(RoverAction.Transmit);
}
}
if (adjacentSquares[4] == TerrainType.Smooth || adjacentSquares[4] == TerrainType.Rough)
{
yield return(RoverAction.CollectSample);
if (rover.SamplesCollected >= 3)
{
yield return(RoverAction.ProcessSamples);
}
}
if (SmoothSquare != Direction.None)
{
moveDir = SmoothSquare;
}
else
{
moveDir = Direction.None;
for (Int32 i = 0; i < 5; i++)
{
if (adjacentSquares[i] == TerrainType.Rough)
{
moveDir = (Direction)i;
destination = Direction.None;
break;
}
}
if (moveDir == Direction.None)
{
if (destination == Direction.None)
{
SetDestination();
}
if (adjacentSquares[(Int32)destination] != TerrainType.Impassable)
{
moveDir = destination;
}
else
{
FindOpenSquare();
}
}
}
CheckStuck();
yield return(Move());
if (rover.MovesLeft == 0 || rover.Power == 0)
{
yield break;
}
}
}
public Boolean Step(ScratchRover rover)
{
if (rover == null)
{
throw new ArgumentNullException(nameof(rover));
}
Direction smoothSquare = Direction.None;
SenseAdjacentSquares(rover);
for (Int32 i = 0; i < Direction.DirectionCount; i++)
{
if (adjacentSquares[i] == TerrainType.Smooth)
{
smoothSquare = (Direction)i;
break;
}
}
if (rover.Power < 30 || (smoothSquare == Direction.None && adjacentSquares[4] == TerrainType.Smooth))
{
if (rover.Power < 51 * rover.MovesLeft)
{
rover.CollectPower();
}
}
if (rover.MovesLeft < 3)
{
if (rover.MovesLeft == 2)
{
rover.ProcessSamples();
rover.Transmit();
return(true);
}
rover.Transmit();
}
if (rover.Power < 41)
{
if (rover.Power > 10)
{
rover.CollectPower();
}
if (rover.Power < 41)
{
rover.Transmit();
}
}
if (adjacentSquares[4] == TerrainType.Smooth || adjacentSquares[4] == TerrainType.Rough)
{
rover.CollectSample();
if (rover.SamplesCollected >= 3)
{
rover.ProcessSamples();
}
}
if (adjacentSquares.Contains(TerrainType.Smooth))
{
if (adjacentSquares[0] == TerrainType.Smooth)
{
rover.Move(Direction.Up);
}
else if (adjacentSquares[1] == TerrainType.Smooth)
{
rover.Move(Direction.Right);
}
else if (adjacentSquares[2] == TerrainType.Smooth)
{
rover.Move(Direction.Down);
}
else if (adjacentSquares[3] == TerrainType.Smooth)
{
rover.Move(Direction.Left);
}
}
else
{
Int32 num = _random.Next(0, 4);
if (num == 0)
{
rover.Move(Direction.Up);
}
else if (num == 1)
{
rover.Move(Direction.Right);
}
else if (num == 2)
{
rover.Move(Direction.Down);
}
else if (num == 3)
{
rover.Move(Direction.Left);
}
}
return(false);
}
public Boolean Step(ScratchRover rover)
{
// Sense nearby and find a path and anything else free
SenseAdjacentSquares(rover);
if (_mapDirty == true || path.Count == 0)
{
do
{
AnalyzeTerrain(_posX, _posY);
roughTerrainDistMultiplier = 70.0 * rover.MovesLeft / rover.Power; // Optimization target
if (roughTerrainDistMultiplier > 3)
{
roughTerrainDistMultiplier = 3; // Optimization target
}
else if (roughTerrainDistMultiplier < 1)
{
roughTerrainDistMultiplier = 1;
}
ScratchDijkstras pathFinder = new ScratchDijkstras(_mappedTerrain);
path = pathFinder.BeginSolve(_posX, _posY, roughTerrainDistMultiplier);
if (path.Count < 1)
{
if (pathFinder.destinationIndex == -1)
{
return(true); // We have no more squares to go to.
}
// Found an unreachable square
_mappedTerrain[pathFinder.destinationIndex] = TerrainType.Impassable;
}
} while (path.Count == 0);
}
_moveDir = path[0];
path.RemoveAt(0);
// Collect samples and power, move, process, and transmit - anything needing power or moves
if (rover.MovesLeft < 5)
{
if (rover.MovesLeft == 4)
{
rover.CollectPower();
if (rover.Power > 40 && _adjacentSquares[4] == TerrainType.Smooth)
{
rover.CollectSample();
rover.ProcessSamples();
}
else if (rover.Power > 30)
{
rover.ProcessSamples();
}
}
else if (rover.MovesLeft == 3)
{
if (rover.Power > 40 && _adjacentSquares[4] == TerrainType.Smooth)
{
rover.CollectSample();
}
else
{
rover.CollectPower();
}
if (rover.Power > 30)
{
rover.ProcessSamples();
}
}
else if (rover.MovesLeft == 2)
{
if (rover.Power > 30)
{
rover.ProcessSamples();
}
}
rover.Transmit();
return(true); // Out of moves, end simulation
}
if (rover.Power < 101)
{
if (rover.Power < 11)
{
if (_potentialPower[0] + rover.Power < 11)
{
rover.Transmit();
}
else
{
rover.CollectPower();
}
}
if (rover.Power < 101)
{
_lowPower = true;
}
if (rover.Power < 51)
{
if (rover.Power > 10 && _adjacentSquares[4] == TerrainType.Smooth)
{
rover.CollectPower();
}
if (rover.Power < 51)
{
rover.Transmit();
}
}
}
if ((rover.Power + _potentialPower[1]) / rover.MovesLeft > 70)
{
_lowPower = false;
}
if (_potentialPower[0] > 0)
{
if (rover.Power < 30 || _potentialPower[1] == 0)
{
if (rover.Power / rover.MovesLeft < 51)
{
rover.CollectPower();
}
}
}
if (_adjacentSquares[4] == TerrainType.Smooth || _adjacentSquares[4] == TerrainType.Rough)
{
if (!(_lowPower && _potentialPower[1] > 0))
{
rover.CollectSample();
if (rover.SamplesCollected >= 3 && rover.Power > 40)
{
rover.ProcessSamples();
}
}
}
Move(rover);
return(rover.MovesLeft == 0 || rover.Power == 0);
}
public Boolean Step(ScratchRover rover)
{
Direction SmoothSquare = Direction.None;
SenseAdjacentSquares(rover);
for (Int32 i = 0; i < 5; i++)
{
if (adjacentSquares[i] == TerrainType.Smooth)
{
SmoothSquare = (Direction)i;
break;
}
}
if (rover.Power < 30 || (SmoothSquare == Direction.None && adjacentSquares[4] == TerrainType.Smooth))
{
if (rover.Power / rover.MovesLeft < 51)
{
rover.CollectPower();
}
}
if (rover.MovesLeft < 3)
{
if (rover.MovesLeft == 2)
{
rover.ProcessSamples();
}
rover.Transmit();
}
if (rover.Power < 41)
{
if (rover.Power > 10)
{
rover.CollectPower();
}
if (rover.Power < 41)
{
rover.Transmit();
}
}
if (adjacentSquares[4] == TerrainType.Smooth || adjacentSquares[4] == TerrainType.Rough)
{
rover.CollectSample();
if (rover.SamplesCollected >= 3)
{
rover.ProcessSamples();
}
}
if (SmoothSquare != Direction.None)
{
moveDir = SmoothSquare;
}
else
{
moveDir = Direction.None;
for (Int32 i = 0; i < 5; i++)
{
if (adjacentSquares[i] == TerrainType.Rough)
{
moveDir = (Direction)i;
destination = Direction.None;
break;
}
}
if (moveDir == Direction.None)
{
if (destination == Direction.None)
{
SetDestination();
}
if (adjacentSquares[(Int32)destination] != TerrainType.Impassable)
{
moveDir = destination;
}
else
{
FindOpenSquare();
}
}
}
CheckStuck();
Move(rover);
return(rover.MovesLeft == 0 || rover.Power == 0);
}
public void Simulate(IRover rover)
{
var scratchRover = new ScratchRover(rover);
Ai.Simulate(scratchRover);
}
