65081    {
65082        
65083        
65084        
65085        
65086        
65087        
65088        
65089        
65090        
65091        
65092        
65093        
65094        
65095        
65096        
65097        
65098        
65099        
65100        
65101        
65102        
65103        
65104        
65105        
65106        
65107        
65108        
65109        
65110        
65111        double num = steps;
65116        val2.X = (double)
genRand.Next(10, 21) * 0.1 * (double)direction;
 
65117        val2.Y = (double)
genRand.Next(-10, 10) * 0.01;
 
65120        {
65121            if (num > 0.0)
65122            {
65126                {
65128                }
65130                {
65132                }
65133                if (num == 1.0 && 
num2 < 10.0)
 
65134                {
65136                }
65137            }
65138            else
65139            {
65141            }
65142            if (val.
Y > Main.rockLayer && num > 0.0)
 
65143            {
65144                num = 0.0;
65145            }
65146            num -= 1.0;
65152            {
65154            }
65155            if (
num4 > Main.maxTilesX - 1)
 
65156            {
65157                num4 = Main.maxTilesX - 1;
 
65158            }
65160            {
65162            }
65163            if (
num6 > Main.maxTilesY)
 
65164            {
65165                num6 = Main.maxTilesY;
 
65166            }
65168            {
65170                {
65171                    if (
Math.
Abs((
double)
k - val.
X) + 
Math.
Abs((
double)
l - val.
Y) < 
num2 * 0.5 * (1.0 + (
double)
genRand.Next(-10, 11) * 0.015) && Main.tile[
k, 
l].type != 31 && Main.tile[
k, 
l].type != 22)
 
65172                    {
65173                        Main.tile[
k, 
l].active(active: 
false);
 
65174                    }
65175                }
65176            }
65178            val2.Y += (double)
genRand.Next(-10, 10) * 0.1;
 
65179            if (val.
Y < (
double)(
j - 20))
 
65180            {
65181                val2.Y += (double)
genRand.Next(20) * 0.01;
 
65182            }
65183            if (val.
Y > (
double)(
j + 20))
 
65184            {
65185                val2.Y -= (double)
genRand.Next(20) * 0.01;
 
65186            }
65188            {
65189                val2.Y = -0.5;
65190            }
65192            {
65193                val2.Y = 0.5;
65194            }
65195            val2.X += (double)
genRand.Next(-10, 11) * 0.01;
 
65196            switch (direction)
65197            {
65198            case -1:
65200                {
65201                    val2.X = -0.5;
65202                }
65204                {
65205                    val2.X = -2.0;
65206                }
65207                break;
65208            case 1:
65210                {
65211                    val2.X = 0.5;
65212                }
65214                {
65215                    val2.X = 2.0;
65216                }
65217                break;
65218            }
65224            {
65226            }
65227            if (
num4 > Main.maxTilesX - 1)
 
65228            {
65229                num4 = Main.maxTilesX - 1;
 
65230            }
65232            {
65234            }
65235            if (
num6 > Main.maxTilesY)
 
65236            {
65237                num6 = Main.maxTilesY;
 
65238            }
65240            {
65242                {
65243                    if (
Math.
Abs((
double)
m - val.
X) + 
Math.
Abs((
double)
n - val.
Y) < 
num2 * 1.1 * (1.0 + (
double)
genRand.Next(-10, 11) * 0.015) && Main.tile[
m, 
n].wall != 3)
 
65244                    {
65245                        if (Main.tile[
m, 
n].type != 25 && 
n > 
j + 
genRand.Next(3, 20))
 
65246                        {
65247                            Main.tile[
m, 
n].active(active: 
true);
 
65248                        }
65249                        Main.tile[
m, 
n].active(active: 
true);
 
65250                        if (Main.tile[
m, 
n].type != 31 && Main.tile[
m, 
n].type != 22)
 
65251                        {
65252                            Main.tile[
m, 
n].type = 25;
 
65253                        }
65254                        if (Main.tile[
m, 
n].wall == 2)
 
65255                        {
65256                            Main.tile[
m, 
n].wall = 0;
 
65257                        }
65258                    }
65259                }
65260            }
65262            {
65264                {
65266                    {
65268                        {
65270                        }
65273                    }
65274                }
65275            }
65276        }
65278        {
65279            int num9 = (int)val.
X;
 
65282            {
65283            }
65285        }
65286    }
static double Abs(double value)
 
static UnifiedRandom genRand
 
static void PlaceWall(int i, int j, int type, bool mute=false)
 
static void TileRunner(int i, int j, double strength, int steps, int type, bool addTile=false, double speedX=0.0, double speedY=0.0, bool noYChange=false, bool overRide=true, int ignoreTileType=-1)