public static RoboField CreateField(FieldType type, RoboBoard board)
{
RoboField field = CreateField(type);
field.Board = board;
return(field);
}
private void SetField(RoboField[,] fields, RoboField field, int x, int y)
{
field.X = x;
field.Y = y;
field.Board = this;
fields[x, y] = field;
}
public static RoboField DecodeField(char encoded)
{
if (RoboField.FIELDCODING.ContainsKey(encoded))
{
return(RoboField.CreateField(RoboField.FIELDCODING[encoded]));
}
return(RoboField.CreateField((FieldType)((int)encoded - (int)'a')));
}
private void Clear(RoboField[,] fields, Size size)
{
if (size == null)
{
return;
}
for (int y = 0; y < size.Height; y++)
{
for (int x = 0; x < size.Width; x++)
{
SetField(fields, RoboField.CreateField(FieldType.Empty), x, y);
}
}
}
public void MirrorFieldsVertical()
{
RoboField[,] fields = new RoboField[Size.Width, Size.Height];
if (Fields != null)
{
for (int i = 0; i < Size.Width; i++)
{
for (int j = 0; j < Size.Height; j++)
{
Fields[i, j].MirrorVertical();
fields[i, Size.Height - j - 1] = Fields[i, j];
}
}
}
_fields = fields;
}
public void MirrorFieldsHorizontal()
{
RoboField[,] fields = new RoboField[Size.Width, Size.Height];
if (Fields != null)
{
for (int i = 0; i < Size.Width; i++)
{
for (int j = 0; j < Size.Height; j++)
{
Fields[i, j].MirrorHorizontal();
fields[Size.Width - i - 1, j] = Fields[i, j];
}
}
}
_fields = fields;
}
public void RotateFields()
{
RoboField[,] fields = new RoboField[Size.Height, Size.Width];
if (Fields != null)
{
for (int i = 0; i < Size.Width; i++)
{
for (int j = 0; j < Size.Height; j++)
{
Fields[i, j].Rotate();
fields[Size.Height - j - 1, i] = Fields[i, j];
}
}
}
_size = new Size(Size.Height, Size.Width);
_fields = fields;
}
public void Load(TextReader reader, Difficulty difficulty)
{
Difficulty = difficulty;
Size = GetSize(reader.ReadLine());
for (int y = 0; y < Size.Height; y++)
{
for (int x = 0; x < Size.Width; x++)
{
RoboField field = null;
if (y == 0 || x == 0 || y == Size.Height - 1 || x == Size.Width - 1)
{
field = (difficulty == Difficulty.Hard ?
RoboField.CreateField(FieldType.Hole) : RoboField.DecodeField('p'));
}
else
{
char encoded = (char)reader.Read();
if (encoded == '\r' || encoded == '\n')
{
x--;
continue;
}
field = (difficulty == Difficulty.Easy &&
(encoded == RoboField.EncodeField(FieldType.Hole) ||
encoded == RoboField.EncodeField(FieldType.Oil) ||
encoded == RoboField.EncodeField(FieldType.ScrapLeftRight) ||
encoded == RoboField.EncodeField(FieldType.ScrapUpDown))) ?
RoboField.DecodeField(' ') :
RoboField.DecodeField(encoded);
}
SetField(field, x, y);
}
//new line?!
if (y > 0 && y < Size.Height - 1)
{
reader.Read();
}
}
}
/// <summary>
/// Performs a robot movement.
/// </summary>
/// <param name="position">Position of the robot before the action.</param>
/// <param name="board">Board to perform action on.</param>
/// <returns>Position of robot after performing the action.</returns>
public override RoboPosition PerformAction(RoboPosition position, RoboBoard board)
{
RoboField field = board.GetField(position);
if (!field.CanLeave(this.Direction))
{
return(position);
}
RoboPosition result = PerformAction(position);
RoboField neighbor = board.GetField(result);
if (neighbor == null || !neighbor.CanEnter(RoboRotation.Rotate(this.Direction, Rotation.Around)))
{
return(position);
}
return(result);
}
public void SetSize(int x, int y)
{
RoboField[,] fields = new RoboField[x + 2, y + 2];
Clear(fields, new Size(x + 2, y + 2));
if (Fields != null)
{
for (int i = 0; i < x + 2 && i < Size.Width; i++)
{
for (int j = 0; j < y + 2 && j < Size.Height; j++)
{
fields[i, j] = Fields[i, j];
}
}
}
_size = new Size(x + 2, y + 2);
_fields = fields;
}
private RoboBoard GetBoard(RoboBoard original, RoboPlayer actualPlayer, IEnumerable <RoboPlayer> players)
{
RoboBoard board = Board.CopyBoard();
if (Interaction == RoboPlayerInteraction.Blocked)
{
foreach (RoboPlayer player in players)
{
if (player == actualPlayer ||
board.GetField(player.Position).IsDestination ||
player.Position.IsDead)
{
continue;
}
board.Fields[player.Position.X, player.Position.Y] =
RoboField.CreateField(FieldType.WallDown | FieldType.WallUp | FieldType.WallLeft | FieldType.WallRight);
}
}
return(board);
}
public override string ToString()
{
return(RoboField.EncodeField(FieldType).ToString());
}
public static RoboField CreateField(FieldType type)
{
RoboField result = Activator.CreateInstance(GetTypeOf(type), type) as RoboField;
return(result);
}
public RoboPosition GetStartPosition()
{
RoboField start = GetStart();
return(new RoboPosition(start.X, start.Y, start.StartDirection));
}
public void SetField(RoboField field, int x, int y)
{
SetField(Fields, field, x, y);
}
