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); }