oceanCave()

static void Terraria.WorldGen.oceanCave ( int i, int j )

inlinestatic

Definition at line 70364 of file WorldGen.cs.

    {
        if (GenVars.numOceanCaveTreasure >= GenVars.maxOceanCaveTreasure)
        {
            GenVars.numOceanCaveTreasure = 0;
        }
        Vector2D vector2D = default(Vector2D);
        vector2D.X = i;
        vector2D.Y = j;
        Vector2D vector2D2 = default(Vector2D);
        if (i < Main.maxTilesX / 2)
        {
            vector2D2.X = 0.25 + genRand.NextDouble() * 0.25;
        }
        else
        {
            vector2D2.X = -0.35 - genRand.NextDouble() * 0.5;
        }
        vector2D2.Y = 0.4 + genRand.NextDouble() * 0.25;
        ushort num = 264;
        ushort num12 = 53;
        ushort num15 = 397;
        double num16 = genRand.Next(17, 25);
        double num17 = genRand.Next(600, 800);
        double num18 = 4.0;
        bool flag = true;
        while (num16 > num18 && num17 > 0.0)
        {
            bool flag2 = true;
            bool flag3 = true;
            bool flag4 = true;
            if (vector2D.X > (double)(beachDistance - 50) && vector2D.X < (double)(Main.maxTilesX - beachDistance + 50))
            {
                num16 *= 0.96;
                num17 *= 0.96;
            }
            if (num16 < num18 + 2.0 || num17 < 20.0)
            {
                flag4 = false;
            }
            if (flag)
            {
                num16 -= 0.01 + genRand.NextDouble() * 0.01;
                num17 -= 0.5;
            }
            else
            {
                num16 -= 0.02 + genRand.NextDouble() * 0.02;
                num17 -= 1.0;
            }
            if (flag4)
            {
                GenVars.oceanCaveTreasure[GenVars.numOceanCaveTreasure].X = (int)vector2D.X;
                GenVars.oceanCaveTreasure[GenVars.numOceanCaveTreasure].Y = (int)vector2D.Y;
            }
            int num19 = (int)(vector2D.X - num16 * 3.0);
            int num20 = (int)(vector2D.X + num16 * 3.0);
            int num21 = (int)(vector2D.Y - num16 * 3.0);
            int num2 = (int)(vector2D.Y + num16 * 3.0);
            if (num19 < 1)
            {
                num19 = 1;
            }
            if (num20 > Main.maxTilesX - 1)
            {
                num20 = Main.maxTilesX - 1;
            }
            if (num21 < 1)
            {
                num21 = 1;
            }
            if (num2 > Main.maxTilesY - 1)
            {
                num2 = Main.maxTilesY - 1;
            }
            for (int k = num19; k < num20; k++)
            {
                for (int l = num21; l < num2; l++)
                {
                    if (badOceanCaveTiles(k, l))
                    {
                        continue;
                    }
                    double num3 = new Vector2D(Math.Abs((double)k - vector2D.X), Math.Abs((double)l - vector2D.Y)).Length();
                    if (flag4 && num3 < num16 * 0.5 + 1.0)
                    {
                        Main.tile[k, l].type = num;
                        Main.tile[k, l].active(active: false);
                    }
                    else if (num3 < num16 * 1.5 + 1.0 && Main.tile[k, l].type != num)
                    {
                        if ((double)l < vector2D.Y)
                        {
                            if ((vector2D2.X < 0.0 && (double)k < vector2D.X) || (vector2D2.X > 0.0 && (double)k > vector2D.X))
                            {
                                if (num3 < num16 * 1.1 + 1.0)
                                {
                                    Main.tile[k, l].type = num15;
                                    if (Main.tile[k, l].liquid == byte.MaxValue)
                                    {
                                        Main.tile[k, l].wall = 0;
                                    }
                                }
                                else if (Main.tile[k, l].type != num15)
                                {
                                    Main.tile[k, l].type = num12;
                                }
                            }
                        }
                        else if ((vector2D2.X < 0.0 && k < i) || (vector2D2.X > 0.0 && k > i))
                        {
                            if (Main.tile[k, l].liquid == byte.MaxValue)
                            {
                                Main.tile[k, l].wall = 0;
                            }
                            Main.tile[k, l].type = num12;
                            Main.tile[k, l].active(active: true);
                            if (k == (int)vector2D.X && flag2)
                            {
                                flag2 = false;
                                int num4 = 50 + genRand.Next(3);
                                int num5 = 43 + genRand.Next(3);
                                int num6 = 20 + genRand.Next(3);
                                int num7 = k;
                                int num8 = k + num6;
                                if (vector2D2.X < 0.0)
                                {
                                    num7 = k - num6;
                                    num8 = k;
                                }
                                if (num17 < 100.0)
                                {
                                    num4 = (int)((double)num4 * (num17 / 100.0));
                                    num5 = (int)((double)num5 * (num17 / 100.0));
                                    num6 = (int)((double)num6 * (num17 / 100.0));
                                }
                                if (num16 < num18 + 5.0)
                                {
                                    double num9 = (num16 - num18) / 5.0;
                                    num4 = (int)((double)num4 * num9);
                                    num5 = (int)((double)num5 * num9);
                                    num6 = (int)((double)num6 * num9);
                                }
                                for (int m = num7; m <= num8; m++)
                                {
                                    for (int n = l; n < l + num4 && !badOceanCaveTiles(m, n); n++)
                                    {
                                        if (n > l + num5)
                                        {
                                            if (SolidTile(m, n) && Main.tile[m, n].type != num12)
                                            {
                                                break;
                                            }
                                            Main.tile[m, n].type = num15;
                                        }
                                        else
                                        {
                                            Main.tile[m, n].type = num12;
                                        }
                                        Main.tile[m, n].active(active: true);
                                        if (genRand.Next(3) == 0)
                                        {
                                            Main.tile[m - 1, n].type = num12;
                                            Main.tile[m - 1, n].active(active: true);
                                        }
                                        if (genRand.Next(3) == 0)
                                        {
                                            Main.tile[m + 1, n].type = num12;
                                            Main.tile[m + 1, n].active(active: true);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (num3 < num16 * 1.3 + 1.0 && l > j - 10)
                    {
                        Main.tile[k, l].liquid = byte.MaxValue;
                    }
                    if (!flag3 || k != (int)vector2D.X || !((double)l > vector2D.Y))
                    {
                        continue;
                    }
                    flag3 = false;
                    int num10 = 100;
                    int num11 = 2;
                    for (int num13 = k - num11; num13 <= k + num11; num13++)
                    {
                        for (int num14 = l; num14 < l + num10; num14++)
                        {
                            if (!badOceanCaveTiles(num13, num14))
                            {
                                Main.tile[num13, num14].liquid = byte.MaxValue;
                            }
                        }
                    }
                }
            }
            vector2D += vector2D2;
            vector2D2.X += genRand.NextDouble() * 0.1 - 0.05;
            vector2D2.Y += genRand.NextDouble() * 0.1 - 0.05;
            if (flag)
            {
                if (vector2D.Y > (Main.worldSurface * 2.0 + Main.rockLayer) / 3.0 && vector2D.Y > (double)(j + 30))
                {
                    flag = false;
                }
                vector2D2.Y = Utils.Clamp(vector2D2.Y, 0.35, 1.0);
            }
            else
            {
                if (vector2D.X < (double)(Main.maxTilesX / 2))
                {
                    if (vector2D2.X < 0.5)
                    {
                        vector2D2.X += 0.02;
                    }
                }
                else if (vector2D2.X > -0.5)
                {
                    vector2D2.X -= 0.02;
                }
                if (!flag4)
                {
                    if (vector2D2.Y < 0.0)
                    {
                        vector2D2.Y *= 0.95;
                    }
                    vector2D2.Y += 0.04;
                }
                else if (vector2D.Y < (Main.worldSurface * 4.0 + Main.rockLayer) / 5.0)
                {
                    if (vector2D2.Y < 0.0)
                    {
                        vector2D2.Y *= 0.97;
                    }
                    vector2D2.Y += 0.02;
                }
                else if (vector2D2.Y > -0.1)
                {
                    vector2D2.Y *= 0.99;
                    vector2D2.Y -= 0.01;
                }
                vector2D2.Y = Utils.Clamp(vector2D2.Y, -1.0, 1.0);
            }
            if (vector2D.X < (double)(Main.maxTilesX / 2))
            {
                vector2D2.X = Utils.Clamp(vector2D2.X, 0.1, 1.0);
            }
            else
            {
                vector2D2.X = Utils.Clamp(vector2D2.X, -1.0, -0.1);
            }
        }
        GenVars.numOceanCaveTreasure++;
    }

References Terraria.WorldBuilding.GenVars.maxOceanCaveTreasure, Terraria.Main.maxTilesX, Terraria.Main.maxTilesY, Terraria.WorldBuilding.GenVars.numOceanCaveTreasure, Terraria.WorldBuilding.GenVars.oceanCaveTreasure, Terraria.Main.rockLayer, Terraria.Enums.SolidTile, Terraria.Main.tile, and Terraria.Main.worldSurface.