Exemple #1
0
        void AddCactus(Level Lvl, ushort x, ushort y, ushort z, Random Rand)
        {
            byte height = (byte)Rand.Next(3, 6);
            ushort yy;

            for (yy = 0; yy <= height; yy++) Lvl.skipChange(x, (ushort)(y + yy), z, Block.green);

            int inX = 0, inZ = 0;

            switch (Rand.Next(1, 3))
            {
                case 1: inX = -1; break;
                case 2:
                default: inZ = -1; break;
            }

            for (yy = height; yy <= Rand.Next(height + 2, height + 5); yy++) Lvl.skipChange((ushort)(x + inX), (ushort)(y + yy), (ushort)(z + inZ), Block.green);
            for (yy = height; yy <= Rand.Next(height + 2, height + 5); yy++) Lvl.skipChange((ushort)(x - inX), (ushort)(y + yy), (ushort)(z - inZ), Block.green);
        }
Exemple #2
0
        //
        void AddTree(Level Lvl, ushort x, ushort y, ushort z, Random Rand)
        {
            byte height = (byte)Rand.Next(5, 8);
            for (ushort yy = 0; yy < height; yy++) Lvl.skipChange(x, (ushort)(y + yy), z, Block.trunk);

            short top = (short)(height - Rand.Next(2, 4));

            for (short xx = (short)-top; xx <= top; ++xx)
            {
                for (short yy = (short)-top; yy <= top; ++yy)
                {
                    for (short zz = (short)-top; zz <= top; ++zz)
                    {
                        short Dist = (short)(Math.Sqrt(xx * xx + yy * yy + zz * zz));
                        if (Dist < top + 1)
                        {
                            if (Rand.Next((int)(Dist)) < 2)
                            {
                                try
                                {
                                    Lvl.skipChange((ushort)(x + xx), (ushort)(y + yy + height), (ushort)(z + zz), Block.leaf);
                                }
                                catch { }
                            }
                        }
                    }
                }
            }
        }
Exemple #3
0
        public bool GenerateMap(Level Lvl, string type)
        {
            Server.s.Log("Attempting map gen");
            if (Inuse) { Server.s.Log("Generator in use"); return false; }
            Random rand = new System.Random();
            try
            {
                Inuse = true;
                terrain = new float[Lvl.width * Lvl.height];
                overlay = new float[Lvl.width * Lvl.height];

                if (!type.Equals("ocean"))
                { overlay2 = new float[Lvl.width * Lvl.height]; }

                //float dispAux, pd;
                ushort WaterLevel = (ushort)(Lvl.depth / 2 + 2);
                ushort LavaLevel = 5;

                if (type.Equals("ocean"))
                {
                    WaterLevel = (ushort)(Lvl.depth * 0.85f);
                }

                //Generate the level
                GenerateFault(terrain, Lvl, type, rand);

                //APPLY FILTER to terrain
                FilterAverage(Lvl);

                //CREATE OVERLAY
                //GenerateFault(overlay, Lvl, "overlay", rand);
                Server.s.Log("Creating overlay");
                GeneratePerlinNoise(overlay, Lvl, "", rand);

                if (!type.Equals("ocean") && type != "desert")
                {
                    Server.s.Log("Planning trees");
                    GeneratePerlinNoise(overlay2, Lvl, "", rand);
                }

                Server.s.Log("Converting height map");
                Server.s.Log("And applying overlays");
                float RangeLow = 0.2f;
                float RangeHigh = 0.8f;
                float TreeDens = 0.35f;
                short TreeDist = 3;
                //changes the terrain range based on type, also tree threshold
                switch (type)
                {
                    case "island":
                        RangeLow = 0.4f;
                        RangeHigh = 0.75f;
                        break;
                    case "forest":
                        RangeLow = 0.45f;
                        RangeHigh = 0.8f;
                        TreeDens = 0.7f;
                        TreeDist = 2;
                        break;
                    case "mountains":
                        RangeLow = 0.3f;
                        RangeHigh = 0.9f;
                        TreeDist = 4;
                        break;
                    case "ocean":
                        RangeLow = 0.1f;
                        RangeHigh = 0.6f;
                        break;
                    case "desert":
                        RangeLow = 0.5f;
                        RangeHigh = 0.85f;
                        WaterLevel = 0;
                        TreeDist = 24;
                        break;
                    case "nether":
                    case "hell":
                        RangeLow = .3f;
                        RangeHigh = 1.3f;
                        break;
                    case "arctic":
                        RangeLow = 0.4f;
                        RangeHigh = 0.70f;
                        break;
                    case "sphere":
                    case "dome":
                        RangeLow = 0; // It don't matter, its a ball...
                        RangeHigh = 0; // It don't matter, its a ball...
                        break;
                    default:
                        break;
                }

                //loops though evey X/Z coordinate
                for (int bb = 0; bb < terrain.Length; bb++)
                {
                    ushort x = (ushort)(bb % Lvl.width);
                    ushort y = (ushort)(bb / Lvl.width);
                    ushort z;
                    if (type.Equals("island"))
                    {
                        z = Evaluate(Lvl, Range(terrain[bb], RangeLow - NegateEdge(x, y, Lvl), RangeHigh - NegateEdge(x, y, Lvl)));
                    }
                    else if (type.Equals("arctic"))
                    {
                        z = Evaluate(Lvl, Range(terrain[bb], RangeLow - NegateEdge(x, y, Lvl), RangeHigh - NegateEdge(x, y, Lvl)));
                    }
                    else
                    {
                        z = Evaluate(Lvl, Range(terrain[bb], RangeLow, RangeHigh));
                    }
                    if (type != "hell" && type != "nether")
                    {
                        if (z > WaterLevel)
                        {
                            for (ushort zz = 0; z - zz >= 0; zz++)
                            {
                                if (type == "desert")
                                {
                                    Lvl.skipChange(x, (ushort)(z - zz), y, Block.sand);
                                }
                                else if (overlay[bb] < 0.72f)    //If not zoned for rocks or gravel
                                {
                                    if (type.Equals("island"))      //increase sand height for island
                                    {
                                        if (z > WaterLevel + 2)
                                        {
                                            if (zz == 0) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.grass); }      //top layer
                                            else if (zz < 3) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.dirt); }   //next few
                                            else { Lvl.skipChange(x, (ushort)(z - zz), y, Block.rock); }               //ten rock it
                                        }
                                        else
                                        {
                                            Lvl.skipChange(x, (ushort)(z - zz), y, Block.sand);                        //SAAAND extra for islands
                                        }
                                    }
                                    else if (type.Equals("arctic"))
                                    {
                                        if (z > WaterLevel + 2)
                                        {
                                            if (zz == 0) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.white); }      //top layer
                                            else if (zz < 3) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.white); }   //next few
                                            else { Lvl.skipChange(x, (ushort)(z - zz), y, Block.white); }               //ten rock it
                                        }
                                        else
                                        {
                                            Lvl.skipChange(x, (ushort)(z - zz), y, Block.white);
                                        }
                                    }
                                    else if (type == "desert")
                                    {
                                        Lvl.skipChange(x, (ushort)(z - zz), y, Block.sand);
                                    }
                                    else
                                    {
                                        if (zz == 0) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.grass); }
                                        else if (zz < 3) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.dirt); }
                                        else { Lvl.skipChange(x, (ushort)(z - zz), y, Block.rock); }
                                    }
                                }
                                else
                                {
                                    Lvl.skipChange(x, (ushort)(z - zz), y, Block.rock);    //zoned for above sea level rock floor
                                }
                            }

                            if (overlay[bb] < 0.25f && type != "desert" && type != "arctic")    //Zoned for flowers
                            {
                                int temprand = rand.Next(12);

                                switch (temprand)
                                {
                                    case 10:
                                        Lvl.skipChange(x, (ushort)(z + 1), y, Block.redflower);
                                        break;
                                    case 11:
                                        Lvl.skipChange(x, (ushort)(z + 1), y, Block.yellowflower);
                                        break;
                                    default:
                                        break;
                                }
                            }

                            if (!type.Equals("ocean"))
                            {
                                if (overlay[bb] < 0.65f && overlay2[bb] < TreeDens)
                                {
                                    if (Lvl.GetTile(x, (ushort)(z + 1), y) == Block.air)
                                    {
                                        if (Lvl.GetTile(x, z, y) == Block.grass || type == "desert")
                                        {
                                            if (rand.Next(13) == 0)
                                            {
                                                if (!TreeCheck(Lvl, x, z, y, TreeDist))
                                                {
                                                    if (type == "desert")
                                                        AddCactus(Lvl, x, (ushort)(z + 1), y, rand);
                                                    else
                                                        AddTree(Lvl, x, (ushort)(z + 1), y, rand);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else    //Must be on/under the water line then
                        {
                            for (ushort zz = 0; WaterLevel - zz >= 0; zz++)
                            {
                                if (WaterLevel - zz > z)
                                { Lvl.skipChange(x, (ushort)(WaterLevel - zz), y, Block.water); }    //better fill the water aboce me
                                else if (WaterLevel - zz > z - 3)
                                {
                                    if (!type.Equals("arctic"))
                                    {
                                        if (overlay[bb] < 0.75f)
                                        {
                                            Lvl.skipChange(x, (ushort)(WaterLevel - zz), y, Block.sand);   //sand top
                                        }
                                        else
                                        {
                                            Lvl.skipChange(x, (ushort)(WaterLevel - zz), y, Block.gravel);  //zoned for gravel
                                        }
                                    }
                                    else
                                    {
                                        Lvl.skipChange(x, (ushort)(WaterLevel - zz), y, Block.white);
                                    }
                                }
                                else
                                {
                                    if (!type.Equals("arctic")) { Lvl.skipChange(x, (ushort)(WaterLevel - zz), y, Block.rock); }
                                    else { Lvl.skipChange(x, (ushort)(WaterLevel - zz), y, Block.white); }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (z > LavaLevel)
                        {
                            for (ushort zz = 0; z - zz >= 0; zz++)
                            {
                                if (z > (LavaLevel - 1))
                                {
                                    if (zz == 0) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.rock); }      //top layer
                                    else if (zz < 3) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.rock); }
                                    else if (zz < 2) { Lvl.skipChange(x, (ushort)(z - zz), y, Block.lava); }//next few
                                    else { Lvl.skipChange(x, (ushort)(z - zz), y, Block.obsidian); }
                                }
                                else
                                {
                                    Lvl.skipChange(x, (ushort)(z - zz), y, Block.lava);
                                }
                                if (overlay[bb] < 0.3f)
                                {
                                    switch (rand.Next(13))
                                    {
                                        case 9:
                                        case 10:
                                        case 11:
                                        case 12:
                                            Lvl.skipChange(x, (ushort)(z + 1), y, Block.lava); //change to lava when time
                                            break;
                                        default:
                                            break;
                                    }
                                }
                                // if (zz == z) Lvl.skipChange(x, (ushort)(z - zz), y, Block.opsidian);
                                Lvl.skipChange(x, (ushort)(z), y, (rand.Next(100) % 3 == 1 ? Block.darkgrey : Block.obsidian));
                            }
                        }
                        else
                        {
                            for (ushort zz = 0; LavaLevel - zz >= 0; zz++)
                            {

                                if (LavaLevel - zz > z - 1)
                                { /*if (Lvl.GetTile(x, z, y) == Block.air)*/ Lvl.skipChange(x, (ushort)(LavaLevel - zz), y, Block.lava); }    //better fill the water aboce me
                                else if (LavaLevel - zz > z - 3)
                                {
                                    if (overlay[bb] < .9f)
                                    {
                                        if (zz < z) Lvl.skipChange(x, (ushort)(z - zz), (ushort)(y), Block.lava);
                                        else Lvl.skipChange(x, (ushort)(z - zz), y, Block.rock);
                                    }
                                    else
                                    {
                                        Lvl.skipChange(x, (ushort)(LavaLevel - zz), (ushort)(y - 5), Block.lava);  //killer lava
                                    }
                                }
                                else
                                {
                                    Lvl.skipChange(x, (ushort)(LavaLevel - zz), y, Block.stone); //and just make the rest cobblestone
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Server.ErrorLog(e);
                Server.s.Log("Gen Fail");
                Inuse = false;
                return false;
            }

            terrain = new float[0]; //Derp
            overlay = new float[0]; //Derp
            overlay2 = new float[0]; //Derp

            Inuse = false;

            return true;
        }