Exemple #1
0
        void checkForStartingPointPlacement(Vector2 mousePosition)
        {
            //if (mouseState.LeftButton == ButtonState.Released)
            //    allowStartingPointPlacement = true;
            //else if (allowStartingPointPlacement && mouseState.LeftButton == ButtonState.Pressed)
            //{
            //    allowStartingPointPlacement = false;

                int X = (int)MathHelper.Clamp(mousePosition.X / map.TileSize - 2, 0, map.Width - 2);
                int Y = (int)MathHelper.Clamp(mousePosition.Y / map.TileSize - 2, 0, map.Height - 2);

                BaseObject startingPoint = new BaseObject(new Rectangle(X * map.TileSize, Y * map.TileSize, 5 * map.TileSize, 5 * map.TileSize));
                //startingPoint.Texture = startingPointTexture;

                blocked = false;

                foreach (BaseObject r in map.Resources)
                {
                    if (startingPoint.Rectangle.Intersects(r.Rectangle) || Vector2.Distance(startingPoint.CenterPoint, r.CenterPoint) < map.TileSize * 9)
                    {
                        blocked = true;
                        break;
                    }
                }

                foreach (BaseObject s in map.StartingPoints)
                {
                    if (startingPoint.Rectangle.Intersects(s.Rectangle))
                    {
                        blocked = true;
                        break;
                    }
                }

                int maxX = (int)MathHelper.Clamp(X + 5, 0, map.Width);
                int maxY = (int)MathHelper.Clamp(Y + 5, 0, map.Height);

                for (int x = X; x < maxX; x++)
                {
                    for (int y = Y; y < maxY; y++)
                    {
                        if (!map.Tiles[y, x].Walkable)
                        {
                            blocked = true;
                            break;
                        }
                    }
                }

                //if (!blocked)
                //    map.StartingPoints.Add(startingPoint);
            //}
        }
Exemple #2
0
        void initializeMinimap()
        {
            minimapPosX = minimapBorderSize;
            minimapPosY = uiViewport.Height - minimapSize - minimapBorderSize;
            minimapToMapRatioX = (float)minimapSize / (map.Width * map.TileSize);
            minimapToMapRatioY = (float)minimapSize / (map.Height * map.TileSize);
            minimapToScreenRatioX = (float)minimapSize / worldViewport.Width;
            minimapToScreenRatioY = (float)minimapSize / worldViewport.Height;
            minimap = new Rectangle(minimapPosX, minimapPosY, minimapSize, minimapSize);
            minimapScreenIndicatorBox = new BaseObject(new Rectangle(0, 0, (int)(worldViewport.Width * minimapToMapRatioX), (int)(worldViewport.Height * minimapToMapRatioY)));

            minimapScreenIndicatorBoxLine = new PrimitiveLine(GraphicsDevice, 1);
            minimapScreenIndicatorBoxLine.Colour = Color.White;
        }
Exemple #3
0
        void checkForLeftClick(GameTime gameTime)
        {
            //if (mouseState.LeftButton == ButtonState.Pressed)
            //    allowMiniMapClick = false;
            //else if (mouseState.LeftButton == ButtonState.Released)
            //    allowMiniMapClick = true;

            // clicked on bottom ui
            if (mouseState.Y > worldViewport.Height)
            {
                if (mouseState.LeftButton == ButtonState.Pressed)
                {
                    if (minimap.Contains(mouseState.X, mouseState.Y))
                    {
                        Vector2 mousePosition = new Vector2(mouseState.X, mouseState.Y);
                        Vector2 minimapCenterPoint = new Vector2(minimap.X + minimap.Width / 2f, minimap.Y + minimap.Height / 2f);

                        float distance = Vector2.Distance(mousePosition, minimapCenterPoint);
                        float angle = (float)Math.Atan2(mousePosition.Y - minimapCenterPoint.Y, mousePosition.X - minimapCenterPoint.X);

                        mousePosition = new Vector2(minimapCenterPoint.X + distance * (float)Math.Cos(angle - camera.Rotation), minimapCenterPoint.Y + distance * (float)Math.Sin(angle - camera.Rotation));

                        camera.Pos = new Vector2((mousePosition.X - minimapPosX) / minimapToMapRatioX, (mousePosition.Y - minimapPosY) / minimapToMapRatioY);

                        //camera.Pos = new Vector2((mouseState.X - minimapPosX) / minimapToMapRatioX, (mouseState.Y - minimapPosY) / minimapToMapRatioY);
                    }
                }
            }
            // clicked somewhere above bottom ui
            else
            {
                Vector2 mousePosition = Vector2.Transform(new Vector2(mouseState.X, mouseState.Y), Matrix.Invert(camera.get_transformation(worldViewport)));

                if (state == State.PlacingTile)
                    checkForTileClick();
                else if (state == State.PlacingResource)
                {
                    checkForResourcePlacement(mousePosition);

                    if (!blocked)
                    {
                        int X = (int)MathHelper.Clamp(mousePosition.X / map.TileSize - 1, 0, map.Width - 3);
                        int Y = (int)MathHelper.Clamp(mousePosition.Y / map.TileSize - 1, 0, map.Height - 3);

                        if (mouseState.LeftButton == ButtonState.Pressed)
                        {
                            BaseObject resource = new BaseObject(new Rectangle(X * map.TileSize, Y * map.TileSize, 3 * map.TileSize, 3 * map.TileSize));
                            resource.Texture = roksTexture;
                            resource.Type = 0;
                            map.Resources.Add(resource);
                            blocked = true;
                        }
                    }
                }
                else if (state == State.PlacingStartingPoint)
                {
                    checkForStartingPointPlacement(mousePosition);

                    if (!blocked)
                    {
                        int X = (int)MathHelper.Clamp(mousePosition.X / map.TileSize - 2, 0, map.Width - 2);
                        int Y = (int)MathHelper.Clamp(mousePosition.Y / map.TileSize - 2, 0, map.Height - 2);

                        if (mouseState.LeftButton == ButtonState.Pressed)
                        {
                            BaseObject startingPoint = new BaseObject(new Rectangle(X * map.TileSize, Y * map.TileSize, 5 * map.TileSize, 5 * map.TileSize));
                            startingPoint.Texture = startingPointTexture;
                            map.StartingPoints.Add(startingPoint);
                            blocked = true;
                        }
                    }
                }
                else if (state == State.Erasing)
                {
                    checkForErase();
                }
            }
        }
 public bool IsNearRotated(BaseObject r, float factor)
 {
     Rectangle inflatedRectangle = new Rectangle(X, Y, Width, Height);
     inflatedRectangle.Inflate((int)(Width * factor), (int)(Height * factor));
     return r.Intersects(inflatedRectangle);
 }
        private bool IsAxisCollision(BaseObject theRectangle, Vector2 aAxis)
        {
            //List<int> aRectangleAScalars = new List<int>();
            aRectangleAScalars.Clear();
            aRectangleAScalars.Add(GenerateScalar(theRectangle.UpperLeftCorner, aAxis));
            aRectangleAScalars.Add(GenerateScalar(theRectangle.UpperRightCorner, aAxis));
            aRectangleAScalars.Add(GenerateScalar(theRectangle.LowerLeftCorner, aAxis));
            aRectangleAScalars.Add(GenerateScalar(theRectangle.LowerRightCorner, aAxis));

            //List<int> aRectangleBScalars = new List<int>();
            aRectangleBScalars.Clear();
            aRectangleBScalars.Add(GenerateScalar(UpperLeftCorner, aAxis));
            aRectangleBScalars.Add(GenerateScalar(UpperRightCorner, aAxis));
            aRectangleBScalars.Add(GenerateScalar(LowerLeftCorner, aAxis));
            aRectangleBScalars.Add(GenerateScalar(LowerRightCorner, aAxis));

            int aRectangleAMinimum = aRectangleAScalars.Min();
            int aRectangleAMaximum = aRectangleAScalars.Max();
            int aRectangleBMinimum = aRectangleBScalars.Min();
            int aRectangleBMaximum = aRectangleBScalars.Max();

            if (aRectangleBMinimum <= aRectangleAMaximum && aRectangleBMaximum >= aRectangleAMaximum)
            {
                return true;
            }
            else if (aRectangleAMinimum <= aRectangleBMaximum && aRectangleAMaximum >= aRectangleBMaximum)
            {
                return true;
            }

            return false;
        }
        public virtual bool Intersects(BaseObject theRectangle)
        {
            List<Vector2> aRectangleAxis = new List<Vector2>();
            aRectangleAxis.Add(UpperRightCorner - UpperLeftCorner);
            aRectangleAxis.Add(UpperRightCorner - LowerRightCorner);
            aRectangleAxis.Add(theRectangle.UpperLeftCorner - theRectangle.LowerLeftCorner);
            aRectangleAxis.Add(theRectangle.UpperLeftCorner - theRectangle.UpperRightCorner);

            foreach (Vector2 aAxis in aRectangleAxis)
            {
                if (!IsAxisCollision(theRectangle, aAxis))
                {
                    return false;
                }
            }

            return true;
        }
 public bool Intersects(Rectangle theRectangle)
 {
     BaseObject o = new BaseObject(theRectangle, 0.0f);
     o.CalculateCorners();
     return Intersects(o);
 }
 public void AddPotentialCollision(BaseObject o)
 {
     //lock (PotentialCollisions)
     //{
     potentialCollisions.Add(o);
     //}
 }
Exemple #9
0
        void loadMap(string mapFilePath)
        {
            string[] lines = File.ReadAllLines(mapFilePath);

            string[] widthAndHeight = lines[0].Split(' ');
            width = int.Parse(widthAndHeight[0]);
            height = int.Parse(widthAndHeight[1]);
            int numberOfResources = int.Parse(widthAndHeight[2]);
            int numberOfStartingPoints = int.Parse(widthAndHeight[3]);

            tiles = new MapTile[height, width];

            for (int i = 0; i < height; i++)
            {
                string[] rowOfTiles = lines[i + 1].Split(' ');

                for (int s = 0; s < width; s++)
                {
                    int typeCode = int.Parse(rowOfTiles[s].Substring(0, 1));
                    int pathingCode = int.Parse(rowOfTiles[s].Substring(1, 1));
                    tiles[i, s] = new MapTile(s, i, tileSize, tileSize, typeCode, pathingCode);
                    //if (pathingCode == 1)
                    //    Walls.Add(tiles[i - 1, s]);
                }
            }

            for (int i = height + 1; i < height + 1 + numberOfResources; i++)
            {
                string[] resourceParams = lines[i].Split(' ');

                if (resourceParams[0] == "0")
                {
                    BaseObject resource = new BaseObject(new Rectangle(int.Parse(resourceParams[1]) * TileSize, int.Parse(resourceParams[2]) * TileSize, 3 * TileSize, 3 * TileSize));
                    Resources.Add(resource );
                }
            }

            for (int i = height + 1 + numberOfResources; i < height + 1 + numberOfResources + numberOfStartingPoints; i++)
            {
                string[] resourceParams = lines[i].Split(' ');

                BaseObject startingPoint = new BaseObject(new Rectangle(int.Parse(resourceParams[0]) * TileSize, int.Parse(resourceParams[1]) * TileSize, 5 * TileSize, 5 * TileSize));
                StartingPoints.Add(startingPoint);
            }

            //Util.SortByX(Walls);
        }
Exemple #10
0
        /*public void RotateRightToLeft()
        {
            Queue<MapTile> tileQueue = new Queue<MapTile>();

            for (int y = 0; y < Height; y++)
            {
                for (int x = Width / 2; x < Width; x++)
                {
                    tileQueue.Enqueue(Tiles[y, x]);
                }
            }

            for (int y = Height - 1; y >= 0; y--)
            {
                for (int x = Width / 2 - 1; x >= 0; x--)
                {
                    MapTile tile = tileQueue.Dequeue();

                    Tiles[y, x].Type = tile.Type;
                    Tiles[y, x].Walkable = tile.Walkable;
                }
            }
        }*/
        public void RotateTopToBottom()
        {
            Queue<MapTile> tileQueue = new Queue<MapTile>();

            for (int y = 0; y < Height / 2; y++)
            {
                for (int x = 0; x < Width; x++)
                {
                    tileQueue.Enqueue(Tiles[y, x]);
                }
            }

            for (int y = Height - 1; y >= Height / 2; y--)
            {
                for (int x = Width - 1; x >= 0; x--)
                {
                    MapTile tile = tileQueue.Dequeue();

                    Tiles[y, x].Type = tile.Type;
                    Tiles[y, x].Walkable = tile.Walkable;
                }
            }

            List<BaseObject> resourcesToAdd = new List<BaseObject>();
            for (int i = 0; i < Resources.Count; )
            {
                BaseObject r = Resources[i];

                if (r.Y <= Height * TileSize / 2 - r.Height)
                {
                    BaseObject resource = new BaseObject(new Rectangle(Width * TileSize - r.X - r.Width, Height * TileSize - r.Y - r.Height, r.Width, r.Height));
                    resource.Type = r.Type;
                    resourcesToAdd.Add(resource);

                    i++;
                }
                else
                    Resources.Remove(r);
            }

            foreach (BaseObject r in resourcesToAdd)
                Resources.Add(r);

            List<BaseObject> startingPointsToAdd = new List<BaseObject>();
            for (int i = 0; i < StartingPoints.Count; )
            {
                BaseObject s = StartingPoints[i];

                if (s.Y <= Height * TileSize / 2 - s.Height)
                {
                    BaseObject startingPoint = new BaseObject(new Rectangle(Width * TileSize - s.X - s.Width, Height * TileSize - s.Y - s.Height, s.Width, s.Height));
                    startingPointsToAdd.Add(startingPoint);

                    i++;
                }
                else
                    StartingPoints.Remove(s);
            }

            foreach (BaseObject s in startingPointsToAdd)
                StartingPoints.Add(s);
        }