Exemplo n.º 1
0
        public static void Lands()
        {
            for (int y = 0; y < (displayHeight / CurrentTileSize) + 2; y++)
            {
                for (int x = 0; x < (displayWidth / CurrentTileSize) + 2; x++)
                {
                    Land      land = landArray[Check.Range(cameraLocationX + x, 0, MapWidth - 1), Check.Range(cameraLocationY + y, 0, MapHeight - 1)];
                    Rectangle tile = TileFrame[x, y];

                    if (land.biome == 1)
                    {
                        int grass = Check.LoopIntPos((cameraLocationX + x) + (cameraLocationY + y), 0, 3);
                        spriteBatch.Draw(DrawingBoard.Biomes[1, 0, grass], tile, Color.White);
                        if (land.IsBorder)
                        {
                            spriteBatch.Draw(DrawingBoard.Borders[land.BorderBiome, land.Border], tile, Color.White);
                        }
                    }
                    else if (land.biome == 2)
                    {
                        int snow = Check.LoopIntPos((cameraLocationX + x) + (cameraLocationY + y), 0, 2);
                        spriteBatch.Draw(DrawingBoard.Biomes[2, 0, snow], tile, Color.White);
                    }
                    else if (land.biome == 3)
                    {
                        int sandX = Check.LoopIntPos((cameraLocationX + x), 0, 29);
                        int sandY = Check.LoopIntPos((cameraLocationY + y), 0, 19);
                        spriteBatch.Draw(DrawingBoard.Biomes[3, sandX, sandY], tile, Color.White);
                    }
                    else
                    {
                        spriteBatch.Draw(DrawingBoard.Tiles[0, land.biome, 5], tile, Color.White);
                    }
                }
            }
        }
Exemplo n.º 2
0
        /* DrawTiles;
         * Input Values: cameraLocationX, cameraLocation Y;
         * This function will run a number of times that is less than
         * the display height divided by default tile rendering dimension 50
         * divided by the scale of tile drawings to get number of tiles on screen
         * then add overflow number of 2 divided by tile scale to draw past screen broders (+2)
         * Steps: Determine global tile at current position camera x & y plus
         * the point at which in this function (int x or y) it has already drawn to
         * then check for biome before using tile scale and location data to draw tile
         *
         * --Pending 60x60 Optimization
         */

        public static void Tiles()
        {
            double rnd;
            Color  color = new Color(Color.Black, 0.2f);

            for (int y = 0; y < (displayHeight / CurrentTileSize) + 2; y++)
            {
                for (int x = 0; x < (displayWidth / CurrentTileSize) + 2; x++)
                {
                    /*rnd = Random.Next(0, 10000);
                     * if (rnd == 5 || rnd == 9995 && landArray[cameraLocationX + x, cameraLocationY + y].land == 5)
                     * {
                     *  if (landArray[cameraLocationX + x, cameraLocationY + y].frame < 5 && rnd > 5000)
                     *  {
                     *      landArray[cameraLocationX + x, cameraLocationY + y].frame = Check.Max(landArray[cameraLocationX + x, cameraLocationY + y].frame + 1, 5);
                     *      landArray[cameraLocationX + x + 1, cameraLocationY + y].frame = Check.Max(landArray[cameraLocationX + x + 1, cameraLocationY + y].frame + 1, 5);
                     *      landArray[cameraLocationX + x, cameraLocationY + y + 1].frame = Check.Max(landArray[cameraLocationX + x, cameraLocationY + y + 1].frame + 1, 5);
                     *  }
                     *  else if (landArray[cameraLocationX + x, cameraLocationY + y].frame > 0 && rnd < 5000)
                     *  {
                     *      rnd = Random.Next(3, 6);
                     *      for (int i = 1; i < rnd; i++)
                     *      {
                     *          landArray[cameraLocationX + x, cameraLocationY + y].frame = Check.Min(landArray[cameraLocationX + x, cameraLocationY + y].frame - 1, 0);
                     *          landArray[cameraLocationX + x + i, cameraLocationY + y].frame = Check.Min(landArray[cameraLocationX + x + i, cameraLocationY + y].frame - 1, 0);
                     *          landArray[cameraLocationX + x, cameraLocationY + y + i].frame = Check.Min(landArray[cameraLocationX + x, cameraLocationY + y + i].frame - 1, 0);
                     *          landArray[cameraLocationX + x + i, cameraLocationY + y + i].frame = Check.Min(landArray[cameraLocationX + x + i, cameraLocationY + y + i].frame - 1, 0);
                     *      }
                     *  }
                     * }*/

                    ///
                    // I may be eventually make a Rectangle Container Class to just have them hold the tile information
                    // I may also be able to pre-pack tiles into 16:9 chunks?
                    //
                    // I think this is how I'm going to do it:
                    // First of all we need three separate layers; Biome, Unit, Object
                    // We then need to call these in order, likely in different spriteBatch.End() calls
                    // The biome layer and maybe object (building) layer could then be pre-packed (or rendered)

                    Land land = landArray[Check.Range(cameraLocationX + x, 0, MapWidth - 1), Check.Range(cameraLocationY + y, 0, MapHeight - 1)];

                    if (land.land != 0)
                    {
                        Texture2D texture    = DrawingBoard.Tiles[land.land, land.biome, land.frame];
                        Object    obj        = Objects[land.land];
                        Rectangle tile       = TileFrame[x, y];
                        int[]     adjustLand = { 0, 0 };

                        if (land.land == 5)
                        {
                            int halfTileSize = CurrentTileSize / 2;
                            adjustLand = new int[2] {
                                halfTileSize, -(halfTileSize / 2)
                            };
                        }

                        Rectangle rectangle = new Rectangle(tile.X - (int)((obj.X - 50) * tileScale) + adjustLand[0],
                                                            tile.Y - (int)((obj.Y - 50) * tileScale) + adjustLand[1],
                                                            (int)(obj.X * tileScale), (int)(obj.Y * tileScale));

                        if (Math.Abs(Player.player.tileX - x) < 5 && Math.Abs(Player.player.tileY - y) < 5 &&
                            rectangle.Contains(Player.player.DrawX, Player.player.DrawY))
                        {
                            spriteBatch.Draw(texture, rectangle, color);
                        }
                        else
                        {
                            spriteBatch.Draw(texture, rectangle, Color.White);
                        }
                    }
                }


                /*if (land.IsOwned) {
                 *  spriteBatch.Draw(outline, tile, Color.White); }*/

                /*float fl = 1.0f;
                 * Vector2 origin = new Vector2(0, 0);
                 * if (land.land == 5) {
                 *  origin.X = -12;
                 *  origin.Y = 8;
                 *  fl = 2.0f; }*/

                /*spriteBatch.Draw(texture,
                 *  new Vector2((x - ((obj.X / 50) - 1)) * (CurrentTileSize) + Player.player.TileOffsetXY[0],
                 *      (y - ((obj.Y / 50) - 1)) * (CurrentTileSize) + Player.player.TileOffsetXY[1]),
                 *  new Rectangle(0, 0, obj.X, obj.Y),
                 *  Color.White, 0, origin,
                 *  fl * (float)tileScale, SpriteEffects.None, 1);*/

                //spriteBatch.DrawString(TileInfoFont, Objects[land.land].Name, new Vector2(x * modifiedTileScale, y * modifiedTileScale), Color.Black);
            }
        }
Exemplo n.º 3
0
        public static void Edges()
        {
            // Draw Edges Around Snow
            for (int definition = 0; definition < 2; definition++)
            {
                for (int y = 1; y < 999; y++)
                {
                    for (int x = 1; x < 999; x++)
                    {
                        Land land = landArray[x, y];
                        if (land.biome == 1)
                        {
                            int border = 0;
                            for (int i = 0; i < 4; i++)
                            {
                                if (landArray[x + MovementXY2[i, 0], y + MovementXY2[i, 1]].biome == 2)
                                {
                                    border += (int)Math.Pow(2, i);
                                }
                            }
                            if (border > 0 && border % 3 == 0)
                            {
                                if (border == 15)
                                {
                                    land.biome = 2;
                                }
                                else
                                {
                                    land.IsBorder    = true;
                                    land.BorderBiome = 2;
                                    land.Border      = border / 3;
                                }
                            }
                        }
                        else if (land.biome == 2)
                        {
                            int border = 0;
                            for (int i = 0; i < 4; i++)
                            {
                                Land adjacentLand = landArray[x - MovementXY2[i, 0], y - MovementXY2[i, 1]];
                                if (!adjacentLand.IsBorder && (adjacentLand.biome != 2 || adjacentLand.IsBorder))
                                {
                                    border += (int)Math.Pow(2, i);
                                }
                            }
                            if (border > 0 && border % 3 == 0)
                            {
                                if (border == 15)
                                {
                                    land.biome = 2;
                                }
                                else
                                {
                                    land.biome       = 1;
                                    land.IsBorder    = true;
                                    land.BorderBiome = 2;
                                    land.Border      = border / 3;
                                }
                            }
                        }
                    }
                }
            }

            // Draw Edges Around Sand
            for (int definition = 0; definition < 2; definition++)
            {
                for (int y = 1; y < 999; y++)
                {
                    for (int x = 1; x < 999; x++)
                    {
                        Land land = landArray[x, y];
                        if (land.biome == 1 && !land.IsBorder)
                        {
                            int border = 0;
                            for (int i = 0; i < 4; i++)
                            {
                                if (landArray[x + MovementXY2[i, 0], y + MovementXY2[i, 1]].biome == 3)
                                {
                                    border += (int)Math.Pow(2, i);
                                }
                            }
                            if (border > 0 && border % 3 == 0)
                            {
                                if (border == 15)
                                {
                                    land.biome = 3;
                                }
                                else
                                {
                                    land.IsBorder    = true;
                                    land.BorderBiome = 3;
                                    land.Border      = border / 3;
                                }
                            }
                        }
                        else if (land.biome == 3)
                        {
                            int border = 0;
                            for (int i = 0; i < 4; i++)
                            {
                                Land adjacentLand = landArray[x - MovementXY2[i, 0], y - MovementXY2[i, 1]];
                                if (!adjacentLand.IsBorder && (adjacentLand.biome != 3 || adjacentLand.IsBorder))
                                {
                                    border += (int)Math.Pow(2, i);
                                }
                            }
                            if (border > 0 && border % 3 == 0)
                            {
                                if (border == 15)
                                {
                                    land.biome = 3;
                                }
                                else
                                {
                                    land.biome       = 1;
                                    land.IsBorder    = true;
                                    land.BorderBiome = 3;
                                    land.Border      = border / 3;
                                }
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 4
0
        public static async Task All()
        {
            double rnd;
            byte   biomeHolder;
            Land   checkPosX;
            Land   checkPosY;
            Land   checkNegX;
            Land   checkNegY;
            Land   checkTile;

            /*
             * The following statements will populate the land values of the default array 1000 x 1000
             * as well as the tile cache array currently 400 x 250 which will
             * support the tile scale .1 (10x) on most resolution scales
             * ^^--pending optimization--^^
             * a roll is done to determine some land values as well as if the tile will be a new biome
             * and then check the previously drawn X & Y tiles for water or trees to increase clumping
             * before going on to generate full biomes, to scale
             * the biomes are then expanded on with more complex near-by random tile generation
             * done through multiple rescans of the default global land array for definition
             * default snow i = 40
             * default ore i = 5
             */

            for (int y = 0; y < 1000; y++)
            {
                for (int x = 0; x < 1000; x++)
                {
                    rnd = Random.Next(0, 10000);

                    /////////////////////////
                    // New Biome Initiator //
                    /////////////////////////

                    if (rnd < 5)
                    {
                        biomeHolder = 0;
                    }
                    else
                    {
                        biomeHolder = 1;
                    }

                    /////////////////////////////////////////////////////////////
                    // Randomly Generate and Instantiate Land Stored in Arrays //
                    /////////////////////////////////////////////////////////////

                    landArray[x, y]       = new Land();
                    landArray[x, y].biome = biomeHolder;

                    if (rnd <= 9390)
                    {
                        landArray[x, y].land = 0;
                    }
                    else if (rnd > 9390 && rnd <= 9400)
                    {
                        landArray[x, y].land = 2;
                    }
                    else if (rnd > 9400 && rnd <= 9800)
                    {
                        landArray[x, y].land = 3;
                    }
                    else if (rnd > 9800 && rnd <= 9900)
                    {
                        landArray[x, y].land = 4;
                    }
                    else if (rnd > 9900 && rnd <= 9995)
                    {
                        landArray[x, y].land = 5;
                    }
                    else if (rnd > 9995)
                    {
                        landArray[x, y].land = -6;
                    }

                    /////////////////////
                    // Realistic Water //
                    /////////////////////

                    if (landArray[Check.Min(x - 1, 0), y].land == 2 && rnd < 5300)
                    {
                        landArray[x, y].land = 2;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 2 && rnd < 5300)
                    {
                        landArray[x, y].land = 2;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 2 && landArray[Check.Min(x - 1, 0), y].land == 2 && rnd < 9900)
                    {
                        landArray[x, y].land = 2;
                    }

                    ///////////////////////
                    // Realistic Forests //
                    ///////////////////////

                    if (landArray[Check.Min(x - 1, 0), y].land == 5 && rnd < 3500)
                    {
                        landArray[x, y].land = 5;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 5 && rnd < 3500)
                    {
                        landArray[x, y].land = 5;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 5 && landArray[Check.Min(x - 1, 0), y].land == 5 && rnd < 9600)
                    {
                        landArray[x, y].land = 5;
                    }
                }
            }

            MainMenuOpen       = false;
            Show.CursorOutline = true;
            LogicClock40.Start();
            LogicClock100.Start();
            LogicClock250.Start();
            LogicClock500.Start();
            LogicClock1000.Start();
            UpdateDestination.Start();

            /////////////////////
            // Generate Biomes //
            /////////////////////

            for (int y = 0; y < 1000; y++)
            {
                for (int x = 0; x < 1000; x++)
                {
                    if (landArray[x, y].biome == 0)
                    {
                        rnd = Random.Next(2, 4);
                        landArray[x, y].biome = (int)rnd;
                        Biome(x - 1, y - 1, (int)rnd, landArray);
                    }
                    if (landArray[x, y].land == -6)
                    {
                        landArray[x, y].land = 6;
                        Land(x - 1, y - 1, 6, landArray);
                    }
                }
            }

            /////////////////////////////////////
            // Expanded Deserts || Default i < 50 //
            /////////////////////////////////////

            for (int i = 0; i < 30; i++)
            {
                for (int y = 0; y < 1000; y++)
                {
                    for (int x = 0; x < 1000; x++)
                    {
                        checkTile = landArray[x, y];
                        checkPosX = landArray[Check.Max(x + 1, 999), y];
                        checkPosY = landArray[x, Check.Max(y + 1, 999)];
                        checkNegX = landArray[Check.Min(x - 1, 0), y];
                        checkNegY = landArray[x, Check.Min(y - 1, 0)];
                        if (checkTile.biome != 3)
                        {
                            rnd = Random.Next(0, 1000);
                            if (checkNegX.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkNegY.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosX.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosY.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (rnd > 1120)
                            {
                                landArray[x, y].biome = 3;
                            }
                        }
                    }
                }
            }

            /////////////////////////////////////
            // Expanded Snow || Default i < 50 //
            /////////////////////////////////////

            for (int i = 0; i < 40; i++)
            {
                for (int y = 0; y < 1000; y++)
                {
                    for (int x = 0; x < 1000; x++)
                    {
                        checkTile = landArray[x, y];
                        checkPosX = landArray[Check.Max(x + 1, 999), y];
                        checkPosY = landArray[x, Check.Max(y + 1, 999)];
                        checkNegX = landArray[Check.Min(x - 1, 0), y];
                        checkNegY = landArray[x, Check.Min(y - 1, 0)];
                        if (checkTile.biome != 2)
                        {
                            rnd = Random.Next(0, 1000);
                            if (checkNegX.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkNegY.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosX.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosY.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (rnd > 1120)
                            {
                                landArray[x, y].biome = 2;
                            }
                        }
                    }
                }
            }

            ////////////////////////////////////
            // Sparse Nodes || Default i < 5 //
            ////////////////////////////////////

            for (int i = 0; i < 5; i++)
            {
                for (int y = 0; y < 1000; y++)
                {
                    for (int x = 0; x < 1000; x++)
                    {
                        checkTile = landArray[x, y];
                        checkPosX = landArray[Check.Max(x + 1, 999), y];
                        checkPosY = landArray[x, Check.Max(y + 1, 999)];
                        checkNegX = landArray[Check.Min(x - 1, 0), y];
                        checkNegY = landArray[x, Check.Min(y - 1, 0)];
                        if (landArray[x, y].biome != 3)
                        {
                            rnd = Random.Next(0, 1000);
                            int node = 6;
                            if (Random.Next(0, 6) == 5)
                            {
                                node = Random.Next(10, 19);
                            }

                            if (landArray[Check.Min(x - 1, 0), y].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                            if (landArray[x, Check.Min(y - 1, 0)].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                            if (landArray[Check.Max(x + 1, 999), y].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                            if (landArray[x, Check.Max(y + 1, 999)].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                        }
                        if (checkTile.land != 5 && checkTile.land != 2)
                        {
                            rnd = Random.Next(0, 1000);
                            if (checkNegX.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (checkNegY.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (checkPosX.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (checkPosY.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (rnd > 1050)
                            {
                                checkTile.land = 5;
                            }
                        }
                    }
                }
            }

            Edges();

            Player.WorldItems.Add(new GPS(50, 50, 0), 0);
        }