public Enemy(UPoint pos) : base((pos.ToVector2( ) + new Vector2(0.5f)) * Program.Thread.CellSize)
{
this.TargetToMove = pos;
PreviousDirection = (uint)(((float)Math.Atan2(
Program.Thread.Player.Position.X - Position.X,
Program.Thread.Player.Position.Y - Position.Y) + Math.PI / 4f) / Math.PI * 2f) % 4;
}
public static Tuple <Grid <uint>, UPoint> CreateMaze(UPoint size)
{
Grid <uint> result = new Grid <uint>(size, 3);
result.SetRegion(new UPoint(1, 1), new UPoint(
result.Width - 1,
result.Height - 1), 0);
UPoint start_pos = new UPoint(
IRandom(result.Width - 2) + 1,
IRandom(result.Height - 2) + 1);
result[start_pos] = 1;
UPoint[] queue = new UPoint[(result.Width - 2) * (result.Height - 2)];
queue[0] = start_pos;
UInt32 queue_size = 1;
while (queue_size > 0)
{
UInt32 queue_pos = IRandom(queue_size);
UPoint pos = queue[queue_pos];
queue_size--;
queue[queue_pos] = queue[queue_size];
if (result[pos] == 1)
{
result[pos] = 2;
for (uint i = 0; i < 4; i++)
{
Point d = Dd(i);
UPoint new_pos = (UPoint)(pos + d);
switch (result[new_pos])
{
case 1:
result[new_pos] = 3;
break;
case 0:
result[new_pos] = 1;
queue[queue_size++] = new_pos;
break;
}
}
}
}
for (uint i = 0; i < result.Width; i++)
{
for (uint j = 0; j < result.Height; j++)
{
if (result[i, j] == 2)
{
result[i, j] = 0;
}
else
{
result[i, j] = 1;
}
}
}
return(new Tuple <Grid <uint>, UPoint>(result, start_pos));
}
public T this[UPoint pos] {
get {
return(this[pos.X, pos.Y]);
}
set {
this[pos.X, pos.Y] = value;
}
}
public static Grid <uint> CreateMapFromMaze(Grid <uint> maze)
{
Grid <uint> result = maze.Copy( );
while (true)
{
bool exit = true;
uint maxDistance = uint.MinValue;
UPoint wallToDelete = default(UPoint);
for (uint i = 1; i < result.Width - 1; i++)
{
for (uint j = 1; j < result.Height - 1; j++)
{
if (result[i, j] == 1)
{
UPoint[] near = new UPoint[4];
uint near_size = 0;
for (uint d = 0; d < 4; d++)
{
UPoint new_pos = new UPoint((uint)(i + Dx[d]), (uint)(j + Dy[d]));
if (result[new_pos] == 0)
{
near[near_size++] = new_pos;
}
}
uint min_dist = uint.MaxValue;
for (uint l = 0; l < near_size; l++)
{
for (uint k = l + 1; k < near_size; k++)
{
uint dist = ShortestWayBFS(near[l], near[k], result);
if (min_dist > dist)
{
min_dist = dist;
}
}
}
if (min_dist != uint.MaxValue && min_dist > 2 && (exit || (maxDistance < min_dist)))
{
maxDistance = min_dist;
wallToDelete = new UPoint(i, j);
exit = false;
}
}
}
}
if (exit)
{
break;
}
else
{
result[wallToDelete] = 0;
}
}
return(result);
}
public void SetRegion(UPoint from, UPoint to, T value)
{
for (UInt32 i = from.X; i < to.X; i++)
{
for (UInt32 j = from.Y; j < to.Y; j++)
{
this[i, j] = value;
}
}
}
public Grid(UPoint size, T defaultValue)
{
this._arr = new T[size.X][];
for (UInt32 i = 0; i < size.X; i++)
{
this._arr[i] = new T[size.Y];
for (UInt32 j = 0; j < size.Y; j++)
{
this._arr[i][j] = defaultValue;
}
}
this.Size = size;
}
public override void Update(GameTime time)
{
if (Step > 0)
{
Position += Speed;
Step--;
}
else
{
PositionOnMap = TargetToMove;
Step = StepsToMove;
Tuple <UPoint, uint>[] results = new Tuple <UPoint, uint> [4];
uint results_size = 0;
for (uint i = 0; i < 3; i++)
{
uint d = i >= PreviousDirection ? i + 1 : i;
UPoint new_target = (UPoint)(PositionOnMap + Utils.Dd(d));
if (Program.Thread.Map[new_target] == 0)
{
results[results_size++] = new Tuple <UPoint, uint>(new_target, d);
}
}
if (results_size == 0)
{
results[results_size++] = new Tuple <UPoint, uint>((UPoint)(PositionOnMap + Utils.Dd(PreviousDirection)), PreviousDirection);
}
uint directionIndex = Utils.IRandom(results_size);
TargetToMove = results[directionIndex].Item1;
PreviousDirection = (results[directionIndex].Item2 + 2) % 4;
Speed = (TargetToMove - PositionOnMap).ToVector2( ) * Program.Thread.CellSize / StepsToMove;
}
if (Math.Abs(Position.X - Program.Thread.Player.Position.X) < 32 &&
Math.Abs(Position.Y - Program.Thread.Player.Position.Y) < 32)
{
if (Program.Thread.GameIsOver == false)
{
Program.Thread.OtherInstances.Add(new GameOverLabel( ));
}
Program.Thread.GameIsOver = true;
Program.Thread.Enemies.Clear( );
}
base.Update(time);
}
public static uint ShortestWayBFS(UPoint from, UPoint to, Grid <uint> map)
{
Grid <uint> temp = new Grid <uint>(map.Size, uint.MaxValue);
temp[from] = 0;
Queue <UPoint> q = new Queue <UPoint>( );
q.Enqueue(from);
while (q.Count > 0 && temp[to] == uint.MaxValue)
{
UPoint p = q.Dequeue( );
uint l = temp[p] + 1;
for (uint d = 0; d < 4; d++)
{
UPoint near = (UPoint)(p + Dd(d));
if (map[near] == 0 && temp[near] > l)
{
temp[near] = l;
q.Enqueue(near);
}
}
}
return(temp[to]);
}
public static bool PlaceFree(Vector2 pos, Vector2 maskHalfSize, Grid <uint> map, UPoint cellSize)
{
for (uint
i = (uint)(pos.X - maskHalfSize.X) / cellSize.X,
iTo = (uint)(pos.X + maskHalfSize.X) / cellSize.X; i <= iTo; i++)
{
for (uint
j = (uint)(pos.Y - maskHalfSize.Y) / cellSize.Y,
jTo = (uint)(pos.Y + maskHalfSize.Y) / cellSize.Y; j <= jTo; j++)
{
if (map[i, j] > 0)
{
return(false);
}
}
}
return(true);
}
