Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches

◆ GenerateWorld()

static void Terraria.WorldGen.GenerateWorld ( int seed,
GenerationProgress customProgressObject = null )
inlinestatic

Definition at line 7175 of file WorldGen.cs.

7176 {
7177 remixWorldGen = tempRemixWorldGen;
7178 tenthAnniversaryWorldGen = tempTenthAnniversaryWorldGen;
7179 drunkWorldGen = false;
7180 drunkWorldGenText = false;
7181 Main.afterPartyOfDoom = false;
7182 if (seed == 5162020 || everythingWorldGen)
7183 {
7184 drunkWorldGen = true;
7185 drunkWorldGenText = true;
7186 Main.drunkWorld = true;
7187 Main.rand = new UnifiedRandom();
7188 seed = Main.rand.Next(999999999);
7189 if (!Main.dayTime)
7190 {
7191 Main.time = 0.0;
7192 }
7193 }
7194 else if (seed == 5162021 || seed == 5162011)
7195 {
7196 tenthAnniversaryWorldGen = true;
7197 }
7198 Main.notTheBeesWorld = notTheBees;
7199 if (notTheBees)
7200 {
7201 Main.rand = new UnifiedRandom();
7202 seed = Main.rand.Next(999999999);
7203 }
7204 Main.noTrapsWorld = noTrapsWorldGen;
7205 if (noTrapsWorldGen)
7206 {
7207 Main.rand = new UnifiedRandom();
7208 seed = Main.rand.Next(999999999);
7209 }
7210 if (getGoodWorldGen)
7211 {
7212 Main.getGoodWorld = true;
7213 Main.rand = new UnifiedRandom();
7214 seed = Main.rand.Next(999999999);
7215 }
7216 else
7217 {
7218 Main.getGoodWorld = false;
7219 }
7220 Main.tenthAnniversaryWorld = tenthAnniversaryWorldGen;
7221 if (tenthAnniversaryWorldGen)
7222 {
7223 Main.rand = new UnifiedRandom();
7224 seed = Main.rand.Next(999999999);
7225 }
7226 Main.dontStarveWorld = dontStarveWorldGen;
7227 if (dontStarveWorldGen)
7228 {
7229 Main.rand = new UnifiedRandom();
7230 seed = Main.rand.Next(999999999);
7231 }
7232 Main.remixWorld = remixWorldGen;
7233 if (remixWorldGen)
7234 {
7235 Main.rand = new UnifiedRandom();
7236 seed = Main.rand.Next(999999999);
7237 }
7238 Main.zenithWorld = everythingWorldGen;
7239 Console.WriteLine("Creating world - Seed: {0} Width: {1}, Height: {2}, Evil: {3}, IsExpert: {4}", seed, Main.maxTilesX, Main.maxTilesY, WorldGenParam_Evil, Main.expertMode);
7240 Main.lockMenuBGChange = true;
7241 GenVars.configuration = WorldGenConfiguration.FromEmbeddedPath("Terraria.GameContent.WorldBuilding.Configuration.json");
7242 Hooks.ProcessWorldGenConfig(ref GenVars.configuration);
7243 _lastSeed = seed;
7244 _generator = new WorldGenerator(seed, GenVars.configuration);
7245 _genRand = new UnifiedRandom(seed);
7246 Main.rand = new UnifiedRandom(seed);
7247 GenVars.structures = new StructureMap();
7248 GenVars.desertHiveHigh = Main.maxTilesY;
7249 GenVars.desertHiveLow = 0;
7250 GenVars.desertHiveLeft = Main.maxTilesX;
7251 GenVars.desertHiveRight = 0;
7252 GenVars.worldSurfaceLow = 0.0;
7253 GenVars.worldSurface = 0.0;
7254 GenVars.worldSurfaceHigh = 0.0;
7255 GenVars.rockLayerLow = 0.0;
7256 GenVars.rockLayer = 0.0;
7257 GenVars.rockLayerHigh = 0.0;
7258 GenVars.copper = 7;
7259 GenVars.iron = 6;
7260 GenVars.silver = 9;
7261 GenVars.gold = 8;
7262 GenVars.dungeonSide = 0;
7263 GenVars.jungleHut = (ushort)genRand.Next(5);
7264 GenVars.shellStartXLeft = 0;
7265 GenVars.shellStartYLeft = 0;
7266 GenVars.shellStartXRight = 0;
7267 GenVars.shellStartYRight = 0;
7268 GenVars.PyrX = null;
7269 GenVars.PyrY = null;
7270 GenVars.numPyr = 0;
7271 GenVars.jungleMinX = -1;
7272 GenVars.jungleMaxX = -1;
7273 GenVars.snowMinX = new int[Main.maxTilesY];
7274 GenVars.snowMaxX = new int[Main.maxTilesY];
7275 GenVars.snowTop = 0;
7276 GenVars.snowBottom = 0;
7277 GenVars.skyLakes = 1;
7278 if (Main.maxTilesX > 8000)
7279 {
7280 GenVars.skyLakes++;
7281 }
7282 if (Main.maxTilesX > 6000)
7283 {
7284 GenVars.skyLakes++;
7285 }
7286 GenVars.beachBordersWidth = 275;
7287 GenVars.beachSandRandomCenter = GenVars.beachBordersWidth + 5 + 40;
7288 GenVars.beachSandRandomWidthRange = 20;
7289 GenVars.beachSandDungeonExtraWidth = 40;
7290 GenVars.beachSandJungleExtraWidth = 20;
7291 GenVars.oceanWaterStartRandomMin = 220;
7292 GenVars.oceanWaterStartRandomMax = GenVars.oceanWaterStartRandomMin + 40;
7293 GenVars.oceanWaterForcedJungleLength = 275;
7294 GenVars.leftBeachEnd = 0;
7295 GenVars.rightBeachStart = 0;
7296 GenVars.evilBiomeBeachAvoidance = GenVars.beachSandRandomCenter + 60;
7297 GenVars.evilBiomeAvoidanceMidFixer = 50;
7298 GenVars.lakesBeachAvoidance = GenVars.beachSandRandomCenter + 20;
7299 GenVars.smallHolesBeachAvoidance = GenVars.beachSandRandomCenter + 20;
7300 GenVars.surfaceCavesBeachAvoidance = GenVars.beachSandRandomCenter + 20;
7301 GenVars.surfaceCavesBeachAvoidance2 = GenVars.beachSandRandomCenter + 20;
7302 GenVars.jungleOriginX = 0;
7303 GenVars.snowOriginLeft = 0;
7304 GenVars.snowOriginRight = 0;
7305 GenVars.logX = -1;
7306 GenVars.logY = -1;
7307 GenVars.dungeonLocation = 0;
7308 if (everythingWorldGen)
7309 {
7310 Main.starGame = true;
7311 }
7312 AddGenerationPass("Reset", delegate(GenerationProgress progress, GameConfiguration passConfig)
7313 {
7314 if (genRand.Next(2) == 0)
7315 {
7316 GenVars.crimsonLeft = false;
7317 }
7318 else
7319 {
7320 GenVars.crimsonLeft = true;
7321 }
7322 GenVars.numOceanCaveTreasure = 0;
7323 GenVars.skipDesertTileCheck = false;
7324 growGrassUnderground = false;
7325 gen = true;
7326 Liquid.ReInit();
7327 noTileActions = true;
7328 progress.Message = "";
7329 SetupStatueList();
7330 RandomizeWeather();
7331 Main.cloudAlpha = 0f;
7332 Main.maxRaining = 0f;
7333 Main.raining = false;
7334 heartCount = 0;
7335 GenVars.extraBastStatueCount = 0;
7336 GenVars.extraBastStatueCountMax = 2;
7337 Main.checkXMas();
7338 Main.checkHalloween();
7339 ResetGenerator();
7340 GenVars.UndergroundDesertLocation = Rectangle.Empty;
7341 GenVars.UndergroundDesertHiveLocation = Rectangle.Empty;
7342 GenVars.numLarva = 0;
7343 List<int> list3 = new List<int> { 274, 220, 112, 218, 3019 };
7344 if (remixWorldGen)
7345 {
7346 list3 = new List<int> { 274, 220, 683, 218, 3019 };
7347 }
7348 List<int> list4 = new List<int>();
7349 while (list3.Count > 0)
7350 {
7351 int index = genRand.Next(list3.Count);
7352 int item = list3[index];
7353 list4.Add(item);
7354 list3.RemoveAt(index);
7355 }
7356 GenVars.hellChestItem = list4.ToArray();
7357 int num1086 = 86400;
7358 Main.slimeRainTime = -genRand.Next(num1086 * 2, num1086 * 3);
7359 Main.cloudBGActive = -genRand.Next(8640, 86400);
7360 skipFramingDuringGen = false;
7361 SavedOreTiers.Copper = 7;
7362 SavedOreTiers.Iron = 6;
7363 SavedOreTiers.Silver = 9;
7364 SavedOreTiers.Gold = 8;
7365 GenVars.copperBar = 20;
7366 GenVars.ironBar = 22;
7367 GenVars.silverBar = 21;
7368 GenVars.goldBar = 19;
7369 if (genRand.Next(2) == 0)
7370 {
7371 GenVars.copper = 166;
7372 GenVars.copperBar = 703;
7373 SavedOreTiers.Copper = 166;
7374 }
7375 if ((!dontStarveWorldGen || drunkWorldGen) && genRand.Next(2) == 0)
7376 {
7377 GenVars.iron = 167;
7378 GenVars.ironBar = 704;
7379 SavedOreTiers.Iron = 167;
7380 }
7381 if (genRand.Next(2) == 0)
7382 {
7383 GenVars.silver = 168;
7384 GenVars.silverBar = 705;
7385 SavedOreTiers.Silver = 168;
7386 }
7387 if ((!dontStarveWorldGen || drunkWorldGen) && genRand.Next(2) == 0)
7388 {
7389 GenVars.gold = 169;
7390 GenVars.goldBar = 706;
7391 SavedOreTiers.Gold = 169;
7392 }
7393 crimson = genRand.Next(2) == 0;
7394 if (WorldGenParam_Evil == 0)
7395 {
7396 crimson = false;
7397 }
7398 if (WorldGenParam_Evil == 1)
7399 {
7400 crimson = true;
7401 }
7402 if (GenVars.jungleHut == 0)
7403 {
7404 GenVars.jungleHut = 119;
7405 }
7406 else if (GenVars.jungleHut == 1)
7407 {
7408 GenVars.jungleHut = 120;
7409 }
7410 else if (GenVars.jungleHut == 2)
7411 {
7412 GenVars.jungleHut = 158;
7413 }
7414 else if (GenVars.jungleHut == 3)
7415 {
7416 GenVars.jungleHut = 175;
7417 }
7418 else if (GenVars.jungleHut == 4)
7419 {
7420 GenVars.jungleHut = 45;
7421 }
7422 Main.worldID = genRand.Next(int.MaxValue);
7423 RandomizeTreeStyle();
7424 RandomizeCaveBackgrounds();
7425 RandomizeBackgrounds(genRand);
7426 RandomizeMoonState(genRand);
7427 TreeTops.CopyExistingWorldInfoForWorldGeneration();
7428 GenVars.dungeonSide = ((genRand.Next(2) != 0) ? 1 : (-1));
7429 if (remixWorldGen)
7430 {
7431 if (GenVars.dungeonSide == -1)
7432 {
7433 double num1087 = 1.0 - (double)genRand.Next(20, 35) * 0.01;
7434 GenVars.jungleOriginX = (int)((double)Main.maxTilesX * num1087);
7435 }
7436 else
7437 {
7438 double num1088 = (double)genRand.Next(20, 35) * 0.01;
7439 GenVars.jungleOriginX = (int)((double)Main.maxTilesX * num1088);
7440 }
7441 }
7442 else
7443 {
7444 int minValue3 = 15;
7445 int maxValue12 = 30;
7446 if (tenthAnniversaryWorldGen && !remixWorldGen)
7447 {
7448 minValue3 = 25;
7449 maxValue12 = 35;
7450 }
7451 if (GenVars.dungeonSide == -1)
7452 {
7453 double num1089 = 1.0 - (double)genRand.Next(minValue3, maxValue12) * 0.01;
7454 GenVars.jungleOriginX = (int)((double)Main.maxTilesX * num1089);
7455 }
7456 else
7457 {
7458 double num1090 = (double)genRand.Next(minValue3, maxValue12) * 0.01;
7459 GenVars.jungleOriginX = (int)((double)Main.maxTilesX * num1090);
7460 }
7461 }
7462 int num1091 = genRand.Next(Main.maxTilesX);
7463 if (drunkWorldGen)
7464 {
7465 GenVars.dungeonSide *= -1;
7466 }
7467 if (GenVars.dungeonSide == 1)
7468 {
7469 while ((double)num1091 < (double)Main.maxTilesX * 0.6 || (double)num1091 > (double)Main.maxTilesX * 0.75)
7470 {
7471 num1091 = genRand.Next(Main.maxTilesX);
7472 }
7473 }
7474 else
7475 {
7476 while ((double)num1091 < (double)Main.maxTilesX * 0.25 || (double)num1091 > (double)Main.maxTilesX * 0.4)
7477 {
7478 num1091 = genRand.Next(Main.maxTilesX);
7479 }
7480 }
7481 if (drunkWorldGen)
7482 {
7483 GenVars.dungeonSide *= -1;
7484 }
7485 int num1092 = genRand.Next(50, 90);
7486 double num1093 = (double)Main.maxTilesX / 4200.0;
7487 num1092 += (int)((double)genRand.Next(20, 40) * num1093);
7488 num1092 += (int)((double)genRand.Next(20, 40) * num1093);
7489 int num1094 = num1091 - num1092;
7490 num1092 = genRand.Next(50, 90);
7491 num1092 += (int)((double)genRand.Next(20, 40) * num1093);
7492 num1092 += (int)((double)genRand.Next(20, 40) * num1093);
7493 int num1095 = num1091 + num1092;
7494 if (num1094 < 0)
7495 {
7496 num1094 = 0;
7497 }
7498 if (num1095 > Main.maxTilesX)
7499 {
7500 num1095 = Main.maxTilesX;
7501 }
7502 GenVars.snowOriginLeft = num1094;
7503 GenVars.snowOriginRight = num1095;
7504 GenVars.leftBeachEnd = genRand.Next(GenVars.beachSandRandomCenter - GenVars.beachSandRandomWidthRange, GenVars.beachSandRandomCenter + GenVars.beachSandRandomWidthRange);
7505 if (tenthAnniversaryWorldGen && !remixWorldGen)
7506 {
7507 GenVars.leftBeachEnd = GenVars.beachSandRandomCenter + GenVars.beachSandRandomWidthRange;
7508 }
7509 if (GenVars.dungeonSide == 1)
7510 {
7511 GenVars.leftBeachEnd += GenVars.beachSandDungeonExtraWidth;
7512 }
7513 else
7514 {
7515 GenVars.leftBeachEnd += GenVars.beachSandJungleExtraWidth;
7516 }
7517 GenVars.rightBeachStart = Main.maxTilesX - genRand.Next(GenVars.beachSandRandomCenter - GenVars.beachSandRandomWidthRange, GenVars.beachSandRandomCenter + GenVars.beachSandRandomWidthRange);
7518 if (tenthAnniversaryWorldGen && !remixWorldGen)
7519 {
7520 GenVars.rightBeachStart = Main.maxTilesX - (GenVars.beachSandRandomCenter + GenVars.beachSandRandomWidthRange);
7521 }
7522 if (GenVars.dungeonSide == -1)
7523 {
7524 GenVars.rightBeachStart -= GenVars.beachSandDungeonExtraWidth;
7525 }
7526 else
7527 {
7528 GenVars.rightBeachStart -= GenVars.beachSandJungleExtraWidth;
7529 }
7530 int num1096 = 50;
7531 if (GenVars.dungeonSide == -1)
7532 {
7533 GenVars.dungeonLocation = genRand.Next(GenVars.leftBeachEnd + num1096, (int)((double)Main.maxTilesX * 0.2));
7534 }
7535 else
7536 {
7537 GenVars.dungeonLocation = genRand.Next((int)((double)Main.maxTilesX * 0.8), GenVars.rightBeachStart - num1096);
7538 }
7539 int num1097 = 0;
7540 if (Main.maxTilesX >= 8400)
7541 {
7542 num1097 = 2;
7543 }
7544 else if (Main.maxTilesX >= 6400)
7545 {
7546 num1097 = 1;
7547 }
7548 GenVars.extraBastStatueCountMax = 2 + num1097;
7549 Main.tileSolid[659] = false;
7550 });
7551 AddGenerationPass(new TerrainPass());
7552 AddGenerationPass("Dunes", delegate(GenerationProgress progress, GameConfiguration passConfig)
7553 {
7554 progress.Message = Lang.gen[1].Value;
7555 int random9 = passConfig.Get<WorldGenRange>("Count").GetRandom(genRand);
7556 double num1080 = passConfig.Get<double>("ChanceOfPyramid");
7557 if (drunkWorldGen)
7558 {
7559 num1080 = 1.0;
7560 }
7561 double num1081 = (double)Main.maxTilesX / 4200.0;
7562 GenVars.PyrX = new int[random9 + 3];
7563 GenVars.PyrY = new int[random9 + 3];
7564 DunesBiome dunesBiome = GenVars.configuration.CreateBiome<DunesBiome>();
7565 for (int num1082 = 0; num1082 < random9; num1082++)
7566 {
7567 progress.Set((double)num1082 / (double)random9);
7568 Point origin5 = Point.Zero;
7569 bool flag62 = false;
7570 int num1083 = 0;
7571 while (!flag62)
7572 {
7573 origin5 = RandomWorldPoint(0, 500, 0, 500);
7574 bool flag63 = Math.Abs(origin5.X - GenVars.jungleOriginX) < (int)(600.0 * num1081);
7575 bool flag64 = Math.Abs(origin5.X - Main.maxTilesX / 2) < 300;
7576 bool flag65 = origin5.X > GenVars.snowOriginLeft - 300 && origin5.X < GenVars.snowOriginRight + 300;
7577 num1083++;
7578 if (num1083 >= Main.maxTilesX)
7579 {
7580 flag63 = false;
7581 }
7582 if (num1083 >= Main.maxTilesX * 2)
7583 {
7584 flag65 = false;
7585 }
7586 flag62 = !(flag63 || flag64 || flag65);
7587 }
7588 dunesBiome.Place(origin5, GenVars.structures);
7589 if (genRand.NextDouble() <= num1080)
7590 {
7591 int num1084 = genRand.Next(origin5.X - 200, origin5.X + 200);
7592 for (int num1085 = 0; num1085 < Main.maxTilesY; num1085++)
7593 {
7594 if (Main.tile[num1084, num1085].active())
7595 {
7596 GenVars.PyrX[GenVars.numPyr] = num1084;
7597 GenVars.PyrY[GenVars.numPyr] = num1085 + 20;
7598 GenVars.numPyr++;
7599 break;
7600 }
7601 }
7602 }
7603 }
7604 });
7605 AddGenerationPass("Ocean Sand", delegate(GenerationProgress progress, GameConfiguration passConfig)
7606 {
7607 progress.Message = Language.GetTextValue("WorldGeneration.OceanSand");
7608 for (int num1069 = 0; num1069 < 3; num1069++)
7609 {
7610 progress.Set((double)num1069 / 3.0);
7611 int num1070 = genRand.Next(Main.maxTilesX);
7612 while ((double)num1070 > (double)Main.maxTilesX * 0.4 && (double)num1070 < (double)Main.maxTilesX * 0.6)
7613 {
7614 num1070 = genRand.Next(Main.maxTilesX);
7615 }
7616 int num1071 = genRand.Next(35, 90);
7617 if (num1069 == 1)
7618 {
7619 double num1072 = (double)Main.maxTilesX / 4200.0;
7620 num1071 += (int)((double)genRand.Next(20, 40) * num1072);
7621 }
7622 if (genRand.Next(3) == 0)
7623 {
7624 num1071 *= 2;
7625 }
7626 if (num1069 == 1)
7627 {
7628 num1071 *= 2;
7629 }
7630 int num1073 = num1070 - num1071;
7631 num1071 = genRand.Next(35, 90);
7632 if (genRand.Next(3) == 0)
7633 {
7634 num1071 *= 2;
7635 }
7636 if (num1069 == 1)
7637 {
7638 num1071 *= 2;
7639 }
7640 int num1074 = num1070 + num1071;
7641 if (num1073 < 0)
7642 {
7643 num1073 = 0;
7644 }
7645 if (num1074 > Main.maxTilesX)
7646 {
7647 num1074 = Main.maxTilesX;
7648 }
7649 if (num1069 == 0)
7650 {
7651 num1073 = 0;
7652 num1074 = GenVars.leftBeachEnd;
7653 }
7654 else if (num1069 == 2)
7655 {
7656 num1073 = GenVars.rightBeachStart;
7657 num1074 = Main.maxTilesX;
7658 }
7659 else if (num1069 == 1)
7660 {
7661 continue;
7662 }
7663 int num1075 = genRand.Next(50, 100);
7664 for (int num1076 = num1073; num1076 < num1074; num1076++)
7665 {
7666 if (genRand.Next(2) == 0)
7667 {
7668 num1075 += genRand.Next(-1, 2);
7669 if (num1075 < 50)
7670 {
7671 num1075 = 50;
7672 }
7673 if (num1075 > 200)
7674 {
7675 num1075 = 200;
7676 }
7677 }
7678 for (int num1077 = 0; (double)num1077 < (Main.worldSurface + Main.rockLayer) / 2.0; num1077++)
7679 {
7680 if (Main.tile[num1076, num1077].active())
7681 {
7682 if (num1076 == (num1073 + num1074) / 2 && genRand.Next(6) == 0)
7683 {
7684 GenVars.PyrX[GenVars.numPyr] = num1076;
7685 GenVars.PyrY[GenVars.numPyr] = num1077;
7686 GenVars.numPyr++;
7687 }
7688 int num1078 = num1075;
7689 if (num1076 - num1073 < num1078)
7690 {
7691 num1078 = num1076 - num1073;
7692 }
7693 if (num1074 - num1076 < num1078)
7694 {
7695 num1078 = num1074 - num1076;
7696 }
7697 num1078 += genRand.Next(5);
7698 for (int num1079 = num1077; num1079 < num1077 + num1078; num1079++)
7699 {
7700 if (num1076 > num1073 + genRand.Next(5) && num1076 < num1074 - genRand.Next(5))
7701 {
7702 Main.tile[num1076, num1079].type = 53;
7703 }
7704 }
7705 break;
7706 }
7707 }
7708 }
7709 }
7710 });
7711 AddGenerationPass("Sand Patches", delegate
7712 {
7713 int num1064 = (int)((double)Main.maxTilesX * 0.013);
7714 if (remixWorldGen)
7715 {
7716 num1064 /= 4;
7717 }
7718 for (int num1065 = 0; num1065 < num1064; num1065++)
7719 {
7720 int num1066 = genRand.Next(0, Main.maxTilesX);
7721 int num1067 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
7722 if (remixWorldGen)
7723 {
7724 num1067 = genRand.Next((int)Main.rockLayer - 100, Main.maxTilesY - 350);
7725 }
7726 while ((double)num1066 > (double)Main.maxTilesX * 0.46 && (double)num1066 < (double)Main.maxTilesX * 0.54 && (double)num1067 < Main.worldSurface + 150.0)
7727 {
7728 num1066 = genRand.Next(0, Main.maxTilesX);
7729 num1067 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
7730 }
7731 int num1068 = genRand.Next(15, 70);
7732 int steps2 = genRand.Next(20, 130);
7733 TileRunner(num1066, num1067, num1068, steps2, 53);
7734 }
7735 });
7736 AddGenerationPass("Tunnels", delegate
7737 {
7738 int num1058 = (int)((double)Main.maxTilesX * 0.0015);
7739 if (remixWorldGen)
7740 {
7741 num1058 = (int)((double)num1058 * 1.5);
7742 }
7743 for (int num1059 = 0; num1059 < num1058; num1059++)
7744 {
7745 if (GenVars.numTunnels >= GenVars.maxTunnels - 1)
7746 {
7747 break;
7748 }
7749 int[] array = new int[10];
7750 int[] array2 = new int[10];
7751 int num1060 = genRand.Next(450, Main.maxTilesX - 450);
7752 if (!remixWorldGen)
7753 {
7754 if (tenthAnniversaryWorldGen)
7755 {
7756 num1060 = genRand.Next((int)((double)Main.maxTilesX * 0.2), (int)((double)Main.maxTilesX * 0.8));
7757 }
7758 else
7759 {
7760 while ((double)num1060 > (double)Main.maxTilesX * 0.4 && (double)num1060 < (double)Main.maxTilesX * 0.6)
7761 {
7762 num1060 = genRand.Next(450, Main.maxTilesX - 450);
7763 }
7764 }
7765 }
7766 int num1061 = 0;
7767 bool flag61;
7768 do
7769 {
7770 flag61 = false;
7771 for (int num1062 = 0; num1062 < 10; num1062++)
7772 {
7773 for (num1060 %= Main.maxTilesX; !Main.tile[num1060, num1061].active(); num1061++)
7774 {
7775 }
7776 if (Main.tile[num1060, num1061].type == 53)
7777 {
7778 flag61 = true;
7779 }
7780 array[num1062] = num1060;
7781 array2[num1062] = num1061 - genRand.Next(11, 16);
7782 num1060 += genRand.Next(5, 11);
7783 }
7784 }
7785 while (flag61);
7786 GenVars.tunnelX[GenVars.numTunnels] = array[5];
7787 GenVars.numTunnels++;
7788 for (int num1063 = 0; num1063 < 10; num1063++)
7789 {
7790 TileRunner(array[num1063], array2[num1063], genRand.Next(5, 8), genRand.Next(6, 9), 0, addTile: true, -2.0, -0.3);
7791 TileRunner(array[num1063], array2[num1063], genRand.Next(5, 8), genRand.Next(6, 9), 0, addTile: true, 2.0, -0.3);
7792 }
7793 }
7794 });
7795 AddGenerationPass("Mount Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
7796 {
7797 GenVars.numMCaves = 0;
7798 progress.Message = Lang.gen[2].Value;
7799 int num1050 = (int)((double)Main.maxTilesX * 0.001);
7800 if (remixWorldGen)
7801 {
7802 num1050 = (int)((double)num1050 * 1.5);
7803 }
7804 for (int num1051 = 0; num1051 < num1050; num1051++)
7805 {
7806 progress.Set((double)num1051 / (double)num1050);
7807 int num1052 = 0;
7808 bool flag59 = false;
7809 bool flag60 = false;
7810 int num1053 = genRand.Next((int)((double)Main.maxTilesX * 0.25), (int)((double)Main.maxTilesX * 0.75));
7811 while (!flag60)
7812 {
7813 flag60 = true;
7814 if (!remixWorldGen)
7815 {
7816 while (num1053 > Main.maxTilesX / 2 - 90 && num1053 < Main.maxTilesX / 2 + 90)
7817 {
7818 num1053 = genRand.Next((int)((double)Main.maxTilesX * 0.25), (int)((double)Main.maxTilesX * 0.75));
7819 }
7820 }
7821 for (int num1054 = 0; num1054 < GenVars.numMCaves; num1054++)
7822 {
7823 if (Math.Abs(num1053 - GenVars.mCaveX[num1054]) < 100)
7824 {
7825 num1052++;
7826 flag60 = false;
7827 break;
7828 }
7829 }
7830 if (num1052 >= Main.maxTilesX / 5)
7831 {
7832 flag59 = true;
7833 break;
7834 }
7835 }
7836 if (!flag59)
7837 {
7838 for (int num1055 = 0; (double)num1055 < Main.worldSurface; num1055++)
7839 {
7840 if (Main.tile[num1053, num1055].active())
7841 {
7842 for (int num1056 = num1053 - 50; num1056 < num1053 + 50; num1056++)
7843 {
7844 for (int num1057 = num1055 - 25; num1057 < num1055 + 25; num1057++)
7845 {
7846 if (Main.tile[num1056, num1057].active() && (Main.tile[num1056, num1057].type == 53 || Main.tile[num1056, num1057].type == 151 || Main.tile[num1056, num1057].type == 274))
7847 {
7848 flag59 = true;
7849 }
7850 }
7851 }
7852 if (!flag59)
7853 {
7854 Mountinater(num1053, num1055);
7855 GenVars.mCaveX[GenVars.numMCaves] = num1053;
7856 GenVars.mCaveY[GenVars.numMCaves] = num1055;
7857 GenVars.numMCaves++;
7858 break;
7859 }
7860 }
7861 }
7862 }
7863 }
7864 });
7865 AddGenerationPass("Dirt Wall Backgrounds", delegate(GenerationProgress progress, GameConfiguration passConfig)
7866 {
7867 progress.Message = Lang.gen[3].Value;
7868 int num1047 = 0;
7869 for (int num1048 = 1; num1048 < Main.maxTilesX - 1; num1048++)
7870 {
7871 ushort wall3 = 2;
7872 double value20 = (double)num1048 / (double)Main.maxTilesX;
7873 progress.Set(value20);
7874 bool flag58 = false;
7875 num1047 += genRand.Next(-1, 2);
7876 if (num1047 < 0)
7877 {
7878 num1047 = 0;
7879 }
7880 if (num1047 > 10)
7881 {
7882 num1047 = 10;
7883 }
7884 for (int num1049 = 0; (double)num1049 < Main.worldSurface + 10.0 && !((double)num1049 > Main.worldSurface + (double)num1047); num1049++)
7885 {
7886 if (Main.tile[num1048, num1049].active())
7887 {
7888 wall3 = (ushort)((Main.tile[num1048, num1049].type != 147) ? 2 : 40);
7889 }
7890 if (flag58 && Main.tile[num1048, num1049].wall != 64)
7891 {
7892 Main.tile[num1048, num1049].wall = wall3;
7893 }
7894 if (Main.tile[num1048, num1049].active() && Main.tile[num1048 - 1, num1049].active() && Main.tile[num1048 + 1, num1049].active() && Main.tile[num1048, num1049 + 1].active() && Main.tile[num1048 - 1, num1049 + 1].active() && Main.tile[num1048 + 1, num1049 + 1].active())
7895 {
7896 flag58 = true;
7897 }
7898 }
7899 }
7900 });
7901 AddGenerationPass("Rocks In Dirt", delegate(GenerationProgress progress, GameConfiguration passConfig)
7902 {
7903 progress.Message = Lang.gen[4].Value;
7904 double num1041 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.00015;
7905 for (int num1042 = 0; (double)num1042 < num1041; num1042++)
7906 {
7907 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(0, (int)GenVars.worldSurfaceLow + 1), genRand.Next(4, 15), genRand.Next(5, 40), 1);
7908 }
7909 progress.Set(0.34);
7910 num1041 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.0002;
7911 for (int num1043 = 0; (double)num1043 < num1041; num1043++)
7912 {
7913 int num1044 = genRand.Next(0, Main.maxTilesX);
7914 int num1045 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh + 1);
7915 if (!Main.tile[num1044, num1045 - 10].active())
7916 {
7917 num1045 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh + 1);
7918 }
7919 TileRunner(num1044, num1045, genRand.Next(4, 10), genRand.Next(5, 30), 1);
7920 }
7921 progress.Set(0.67);
7922 num1041 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.0045;
7923 for (int num1046 = 0; (double)num1046 < num1041; num1046++)
7924 {
7925 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh + 1), genRand.Next(2, 7), genRand.Next(2, 23), 1);
7926 }
7927 });
7928 AddGenerationPass("Dirt In Rocks", delegate(GenerationProgress progress, GameConfiguration passConfig)
7929 {
7930 progress.Message = Lang.gen[5].Value;
7931 double num1037 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.005;
7932 for (int num1038 = 0; (double)num1038 < num1037; num1038++)
7933 {
7934 progress.Set((double)num1038 / num1037);
7935 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(2, 6), genRand.Next(2, 40), 0);
7936 }
7937 if (remixWorldGen)
7938 {
7939 for (int num1039 = 0; num1039 < Main.maxTilesX; num1039++)
7940 {
7941 for (int num1040 = (int)Main.worldSurface + genRand.Next(-1, 3); num1040 < Main.maxTilesY; num1040++)
7942 {
7943 if (Main.tile[num1039, num1040].active())
7944 {
7945 if (Main.tile[num1039, num1040].type == 0)
7946 {
7947 Main.tile[num1039, num1040].type = 1;
7948 }
7949 else if (Main.tile[num1039, num1040].type == 1)
7950 {
7951 Main.tile[num1039, num1040].type = 0;
7952 }
7953 }
7954 }
7955 }
7956 }
7957 });
7958 AddGenerationPass("Clay", delegate(GenerationProgress progress, GameConfiguration passConfig)
7959 {
7960 progress.Message = Lang.gen[6].Value;
7961 for (int num1030 = 0; num1030 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2E-05); num1030++)
7962 {
7963 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(0, (int)GenVars.worldSurfaceLow), genRand.Next(4, 14), genRand.Next(10, 50), 40);
7964 }
7965 progress.Set(0.25);
7966 if (remixWorldGen)
7967 {
7968 for (int num1031 = 0; num1031 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 7E-05); num1031++)
7969 {
7970 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayer - 25, Main.maxTilesY - 350), genRand.Next(8, 15), genRand.Next(5, 50), 40);
7971 }
7972 }
7973 else
7974 {
7975 for (int num1032 = 0; num1032 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 5E-05); num1032++)
7976 {
7977 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh + 1), genRand.Next(8, 14), genRand.Next(15, 45), 40);
7978 }
7979 progress.Set(0.5);
7980 for (int num1033 = 0; num1033 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2E-05); num1033++)
7981 {
7982 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh + 1), genRand.Next(8, 15), genRand.Next(5, 50), 40);
7983 }
7984 }
7985 progress.Set(0.75);
7986 for (int num1034 = 5; num1034 < Main.maxTilesX - 5; num1034++)
7987 {
7988 for (int num1035 = 1; (double)num1035 < Main.worldSurface - 1.0; num1035++)
7989 {
7990 if (Main.tile[num1034, num1035].active())
7991 {
7992 for (int num1036 = num1035; num1036 < num1035 + 5; num1036++)
7993 {
7994 if (Main.tile[num1034, num1036].type == 40)
7995 {
7996 Main.tile[num1034, num1036].type = 0;
7997 }
7998 }
7999 break;
8000 }
8001 }
8002 }
8003 });
8004 AddGenerationPass("Small Holes", delegate(GenerationProgress progress, GameConfiguration passConfig)
8005 {
8006 progress.Message = Lang.gen[7].Value;
8007 double worldSurfaceHigh2 = GenVars.worldSurfaceHigh;
8008 for (int num1025 = 0; num1025 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0015); num1025++)
8009 {
8010 double value19 = (double)num1025 / ((double)(Main.maxTilesX * Main.maxTilesY) * 0.0015);
8011 progress.Set(value19);
8012 int type14 = -1;
8013 if (genRand.Next(5) == 0)
8014 {
8015 type14 = -2;
8016 }
8017 int num1026 = genRand.Next(0, Main.maxTilesX);
8018 int num1027 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY);
8019 if (!remixWorldGen && tenthAnniversaryWorldGen)
8020 {
8021 while ((double)num1026 < (double)Main.maxTilesX * 0.2 && (double)num1026 > (double)Main.maxTilesX * 0.8 && (double)num1027 < GenVars.worldSurface)
8022 {
8023 num1026 = genRand.Next(0, Main.maxTilesX);
8024 num1027 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY);
8025 }
8026 }
8027 else
8028 {
8029 while (((num1026 < GenVars.smallHolesBeachAvoidance || num1026 > Main.maxTilesX - GenVars.smallHolesBeachAvoidance) && (double)num1027 < worldSurfaceHigh2) || ((double)num1026 > (double)Main.maxTilesX * 0.45 && (double)num1026 < (double)Main.maxTilesX * 0.55 && (double)num1027 < GenVars.worldSurface))
8030 {
8031 num1026 = genRand.Next(0, Main.maxTilesX);
8032 num1027 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY);
8033 }
8034 }
8035 int num1028 = genRand.Next(2, 5);
8036 int num1029 = genRand.Next(2, 20);
8037 if (remixWorldGen && (double)num1027 > Main.rockLayer)
8038 {
8039 num1028 = (int)((double)num1028 * 0.8);
8040 num1029 = (int)((double)num1029 * 0.9);
8041 }
8042 TileRunner(num1026, num1027, num1028, num1029, type14);
8043 num1026 = genRand.Next(0, Main.maxTilesX);
8044 num1027 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY);
8045 while (((num1026 < GenVars.smallHolesBeachAvoidance || num1026 > Main.maxTilesX - GenVars.smallHolesBeachAvoidance) && (double)num1027 < worldSurfaceHigh2) || ((double)num1026 > (double)Main.maxTilesX * 0.45 && (double)num1026 < (double)Main.maxTilesX * 0.55 && (double)num1027 < GenVars.worldSurface))
8046 {
8047 num1026 = genRand.Next(0, Main.maxTilesX);
8048 num1027 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY);
8049 }
8050 num1028 = genRand.Next(8, 15);
8051 num1029 = genRand.Next(7, 30);
8052 if (remixWorldGen && (double)num1027 > Main.rockLayer)
8053 {
8054 num1028 = (int)((double)num1028 * 0.7);
8055 num1029 = (int)((double)num1029 * 0.9);
8056 }
8057 TileRunner(num1026, num1027, num1028, num1029, type14);
8058 }
8059 });
8060 AddGenerationPass("Dirt Layer Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
8061 {
8062 progress.Message = Lang.gen[8].Value;
8063 double worldSurfaceHigh = GenVars.worldSurfaceHigh;
8064 int num1019 = (int)((double)(Main.maxTilesX * Main.maxTilesY) * 3E-05);
8065 if (remixWorldGen)
8066 {
8067 num1019 *= 2;
8068 }
8069 for (int num1020 = 0; num1020 < num1019; num1020++)
8070 {
8071 double value18 = (double)num1020 / (double)num1019;
8072 progress.Set(value18);
8073 if (GenVars.rockLayerHigh <= (double)Main.maxTilesY)
8074 {
8075 int type13 = -1;
8076 if (genRand.Next(6) == 0)
8077 {
8078 type13 = -2;
8079 }
8080 int num1021 = genRand.Next(0, Main.maxTilesX);
8081 int num1022 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.rockLayerHigh + 1);
8082 while (((num1021 < GenVars.smallHolesBeachAvoidance || num1021 > Main.maxTilesX - GenVars.smallHolesBeachAvoidance) && (double)num1022 < worldSurfaceHigh) || ((double)num1021 >= (double)Main.maxTilesX * 0.45 && (double)num1021 <= (double)Main.maxTilesX * 0.55 && (double)num1022 < Main.worldSurface))
8083 {
8084 num1021 = genRand.Next(0, Main.maxTilesX);
8085 num1022 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.rockLayerHigh + 1);
8086 }
8087 int num1023 = genRand.Next(5, 15);
8088 int num1024 = genRand.Next(30, 200);
8089 if (remixWorldGen)
8090 {
8091 num1023 = (int)((double)num1023 * 1.1);
8092 num1024 = (int)((double)num1024 * 1.9);
8093 }
8094 TileRunner(num1021, num1022, num1023, num1024, type13);
8095 }
8096 }
8097 });
8098 AddGenerationPass("Rock Layer Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
8099 {
8100 progress.Message = Lang.gen[9].Value;
8101 int num1011 = (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00013);
8102 if (remixWorldGen)
8103 {
8104 num1011 = (int)((double)num1011 * 1.1);
8105 }
8106 for (int num1012 = 0; num1012 < num1011; num1012++)
8107 {
8108 double value17 = (double)num1012 / (double)num1011;
8109 progress.Set(value17);
8110 if (GenVars.rockLayerHigh <= (double)Main.maxTilesY)
8111 {
8112 int type11 = -1;
8113 if (genRand.Next(10) == 0)
8114 {
8115 type11 = -2;
8116 }
8117 int num1013 = genRand.Next(6, 20);
8118 int num1014 = genRand.Next(50, 300);
8119 if (remixWorldGen)
8120 {
8121 num1013 = (int)((double)num1013 * 0.7);
8122 num1014 = (int)((double)num1014 * 0.7);
8123 }
8124 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerHigh, Main.maxTilesY), num1013, num1014, type11);
8125 }
8126 }
8127 if (remixWorldGen)
8128 {
8129 num1011 = (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00013 * 0.4);
8130 for (int num1015 = 0; num1015 < num1011; num1015++)
8131 {
8132 if (GenVars.rockLayerHigh <= (double)Main.maxTilesY)
8133 {
8134 int type12 = -1;
8135 if (genRand.Next(10) == 0)
8136 {
8137 type12 = -2;
8138 }
8139 int num1016 = genRand.Next(7, 26);
8140 int steps = genRand.Next(50, 200);
8141 double num1017 = (double)genRand.Next(100, 221) * 0.1;
8142 double num1018 = (double)genRand.Next(-10, 11) * 0.02;
8143 int i5 = genRand.Next(0, Main.maxTilesX);
8144 int j7 = genRand.Next((int)GenVars.rockLayerHigh, Main.maxTilesY);
8145 TileRunner(i5, j7, num1016, steps, type12, addTile: false, num1017, num1018, noYChange: true);
8146 TileRunner(i5, j7, num1016, steps, type12, addTile: false, 0.0 - num1017, 0.0 - num1018, noYChange: true);
8147 }
8148 }
8149 }
8150 });
8151 AddGenerationPass("Surface Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
8152 {
8153 progress.Message = Lang.gen[10].Value;
8154 int num992 = (int)((double)Main.maxTilesX * 0.002);
8155 int num993 = (int)((double)Main.maxTilesX * 0.0007);
8156 int num994 = (int)((double)Main.maxTilesX * 0.0003);
8157 if (remixWorldGen)
8158 {
8159 num992 *= 3;
8160 num993 *= 3;
8161 num994 *= 3;
8162 }
8163 for (int num995 = 0; num995 < num992; num995++)
8164 {
8165 int num996 = genRand.Next(0, Main.maxTilesX);
8166 while (((double)num996 > (double)Main.maxTilesX * 0.45 && (double)num996 < (double)Main.maxTilesX * 0.55) || num996 < GenVars.leftBeachEnd + 20 || num996 > GenVars.rightBeachStart - 20)
8167 {
8168 num996 = genRand.Next(0, Main.maxTilesX);
8169 }
8170 for (int num997 = 0; (double)num997 < GenVars.worldSurfaceHigh; num997++)
8171 {
8172 if (Main.tile[num996, num997].active())
8173 {
8174 TileRunner(num996, num997, genRand.Next(3, 6), genRand.Next(5, 50), -1, addTile: false, (double)genRand.Next(-10, 11) * 0.1, 1.0);
8175 break;
8176 }
8177 }
8178 }
8179 progress.Set(0.2);
8180 for (int num998 = 0; num998 < num993; num998++)
8181 {
8182 int num999 = genRand.Next(0, Main.maxTilesX);
8183 while (((double)num999 > (double)Main.maxTilesX * 0.43 && (double)num999 < (double)Main.maxTilesX * 0.5700000000000001) || num999 < GenVars.leftBeachEnd + 20 || num999 > GenVars.rightBeachStart - 20)
8184 {
8185 num999 = genRand.Next(0, Main.maxTilesX);
8186 }
8187 for (int num1000 = 0; (double)num1000 < GenVars.worldSurfaceHigh; num1000++)
8188 {
8189 if (Main.tile[num999, num1000].active())
8190 {
8191 TileRunner(num999, num1000, genRand.Next(10, 15), genRand.Next(50, 130), -1, addTile: false, (double)genRand.Next(-10, 11) * 0.1, 2.0);
8192 break;
8193 }
8194 }
8195 }
8196 progress.Set(0.4);
8197 for (int num1001 = 0; num1001 < num994; num1001++)
8198 {
8199 int num1002 = genRand.Next(0, Main.maxTilesX);
8200 while (((double)num1002 > (double)Main.maxTilesX * 0.4 && (double)num1002 < (double)Main.maxTilesX * 0.6) || num1002 < GenVars.leftBeachEnd + 20 || num1002 > GenVars.rightBeachStart - 20)
8201 {
8202 num1002 = genRand.Next(0, Main.maxTilesX);
8203 }
8204 for (int num1003 = 0; (double)num1003 < GenVars.worldSurfaceHigh; num1003++)
8205 {
8206 if (Main.tile[num1002, num1003].active())
8207 {
8208 TileRunner(num1002, num1003, genRand.Next(12, 25), genRand.Next(150, 500), -1, addTile: false, (double)genRand.Next(-10, 11) * 0.1, 4.0);
8209 TileRunner(num1002, num1003, genRand.Next(8, 17), genRand.Next(60, 200), -1, addTile: false, (double)genRand.Next(-10, 11) * 0.1, 2.0);
8210 TileRunner(num1002, num1003, genRand.Next(5, 13), genRand.Next(40, 170), -1, addTile: false, (double)genRand.Next(-10, 11) * 0.1, 2.0);
8211 break;
8212 }
8213 }
8214 }
8215 progress.Set(0.6);
8216 for (int num1004 = 0; num1004 < (int)((double)Main.maxTilesX * 0.0004); num1004++)
8217 {
8218 int num1005 = genRand.Next(0, Main.maxTilesX);
8219 while (((double)num1005 > (double)Main.maxTilesX * 0.4 && (double)num1005 < (double)Main.maxTilesX * 0.6) || num1005 < GenVars.leftBeachEnd + 20 || num1005 > GenVars.rightBeachStart - 20)
8220 {
8221 num1005 = genRand.Next(0, Main.maxTilesX);
8222 }
8223 for (int num1006 = 0; (double)num1006 < GenVars.worldSurfaceHigh; num1006++)
8224 {
8225 if (Main.tile[num1005, num1006].active())
8226 {
8227 TileRunner(num1005, num1006, genRand.Next(7, 12), genRand.Next(150, 250), -1, addTile: false, 0.0, 1.0, noYChange: true);
8228 break;
8229 }
8230 }
8231 }
8232 progress.Set(0.8);
8233 double num1007 = (double)Main.maxTilesX / 4200.0;
8234 for (int num1008 = 0; (double)num1008 < 5.0 * num1007; num1008++)
8235 {
8236 try
8237 {
8238 int num1009 = (int)Main.rockLayer;
8239 int num1010 = Main.maxTilesY - 400;
8240 if (num1009 >= num1010)
8241 {
8242 num1009 = num1010 - 1;
8243 }
8244 Caverer(genRand.Next(GenVars.surfaceCavesBeachAvoidance2, Main.maxTilesX - GenVars.surfaceCavesBeachAvoidance2), genRand.Next(num1009, num1010));
8245 }
8246 catch
8247 {
8248 }
8249 }
8250 });
8251 AddGenerationPass("Wavy Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
8252 {
8253 if (dontStarveWorldGen)
8254 {
8255 progress.Message = Language.GetTextValue("WorldGeneration.WavyCaves");
8256 double num983 = (double)Main.maxTilesX / 4200.0;
8257 num983 *= num983;
8258 int num984 = (int)(35.0 * num983);
8259 if (Main.remixWorld)
8260 {
8261 num984 /= 3;
8262 }
8263 int num985 = 0;
8264 int num986 = 80;
8265 for (int num987 = 0; num987 < num984; num987++)
8266 {
8267 double num988 = (double)num987 / (double)(num984 - 1);
8268 progress.Set(num988);
8269 int num989 = genRand.Next((int)Main.worldSurface + 100, Main.UnderworldLayer - 100);
8270 int num990 = 0;
8271 while (Math.Abs(num989 - num985) < num986)
8272 {
8273 num990++;
8274 if (num990 > 100)
8275 {
8276 break;
8277 }
8278 num989 = genRand.Next((int)Main.worldSurface + 100, Main.UnderworldLayer - 100);
8279 }
8280 num985 = num989;
8281 int num991 = 80;
8282 int startX = num991 + (int)((double)(Main.maxTilesX - num991 * 2) * num988);
8283 try
8284 {
8285 WavyCaverer(startX, num989, 12 + genRand.Next(3, 6), 0.25 + genRand.NextDouble(), genRand.Next(300, 500), -1);
8286 }
8287 catch
8288 {
8289 }
8290 }
8291 }
8292 });
8293 AddGenerationPass("Generate Ice Biome", delegate(GenerationProgress progress, GameConfiguration passConfig)
8294 {
8295 progress.Message = Lang.gen[56].Value;
8296 GenVars.snowTop = (int)Main.worldSurface;
8297 int num975 = GenVars.lavaLine - genRand.Next(160, 200);
8298 int num976 = GenVars.lavaLine;
8299 if (remixWorldGen)
8300 {
8301 num976 = Main.maxTilesY - 250;
8302 num975 = num976 - genRand.Next(160, 200);
8303 }
8304 int num977 = GenVars.snowOriginLeft;
8305 int num978 = GenVars.snowOriginRight;
8306 int num979 = 10;
8307 for (int num980 = 0; num980 <= num976 - 140; num980++)
8308 {
8309 progress.Set((double)num980 / (double)(num976 - 140));
8310 num977 += genRand.Next(-4, 4);
8311 num978 += genRand.Next(-3, 5);
8312 if (num980 > 0)
8313 {
8314 num977 = (num977 + GenVars.snowMinX[num980 - 1]) / 2;
8315 num978 = (num978 + GenVars.snowMaxX[num980 - 1]) / 2;
8316 }
8317 if (GenVars.dungeonSide > 0)
8318 {
8319 if (genRand.Next(4) == 0)
8320 {
8321 num977++;
8322 num978++;
8323 }
8324 }
8325 else if (genRand.Next(4) == 0)
8326 {
8327 num977--;
8328 num978--;
8329 }
8330 GenVars.snowMinX[num980] = num977;
8331 GenVars.snowMaxX[num980] = num978;
8332 for (int num981 = num977; num981 < num978; num981++)
8333 {
8334 if (num980 < num975)
8335 {
8336 if (Main.tile[num981, num980].wall == 2)
8337 {
8338 Main.tile[num981, num980].wall = 40;
8339 }
8340 switch (Main.tile[num981, num980].type)
8341 {
8342 case 0:
8343 case 2:
8344 case 23:
8345 case 40:
8346 case 53:
8347 Main.tile[num981, num980].type = 147;
8348 break;
8349 case 1:
8350 Main.tile[num981, num980].type = 161;
8351 break;
8352 }
8353 }
8354 else
8355 {
8356 num979 += genRand.Next(-3, 4);
8357 if (genRand.Next(3) == 0)
8358 {
8359 num979 += genRand.Next(-4, 5);
8360 if (genRand.Next(3) == 0)
8361 {
8362 num979 += genRand.Next(-6, 7);
8363 }
8364 }
8365 if (num979 < 0)
8366 {
8367 num979 = genRand.Next(3);
8368 }
8369 else if (num979 > 50)
8370 {
8371 num979 = 50 - genRand.Next(3);
8372 }
8373 for (int num982 = num980; num982 < num980 + num979; num982++)
8374 {
8375 if (Main.tile[num981, num982].wall == 2)
8376 {
8377 Main.tile[num981, num982].wall = 40;
8378 }
8379 switch (Main.tile[num981, num982].type)
8380 {
8381 case 0:
8382 case 2:
8383 case 23:
8384 case 40:
8385 case 53:
8386 Main.tile[num981, num982].type = 147;
8387 break;
8388 case 1:
8389 Main.tile[num981, num982].type = 161;
8390 break;
8391 }
8392 }
8393 }
8394 }
8395 if (GenVars.snowBottom < num980)
8396 {
8397 GenVars.snowBottom = num980;
8398 }
8399 }
8400 });
8401 AddGenerationPass("Grass", delegate(GenerationProgress progress, GameConfiguration passConfig)
8402 {
8403 double num971 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.002;
8404 for (int num972 = 0; (double)num972 < num971; num972++)
8405 {
8406 progress.Set((double)num972 / num971);
8407 int num973 = genRand.Next(1, Main.maxTilesX - 1);
8408 int num974 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh);
8409 if (num974 >= Main.maxTilesY)
8410 {
8411 num974 = Main.maxTilesY - 2;
8412 }
8413 if (Main.tile[num973 - 1, num974].active() && Main.tile[num973 - 1, num974].type == 0 && Main.tile[num973 + 1, num974].active() && Main.tile[num973 + 1, num974].type == 0 && Main.tile[num973, num974 - 1].active() && Main.tile[num973, num974 - 1].type == 0 && Main.tile[num973, num974 + 1].active() && Main.tile[num973, num974 + 1].type == 0)
8414 {
8415 Main.tile[num973, num974].active(active: true);
8416 Main.tile[num973, num974].type = 2;
8417 }
8418 num973 = genRand.Next(1, Main.maxTilesX - 1);
8419 num974 = genRand.Next(0, (int)GenVars.worldSurfaceLow);
8420 if (num974 >= Main.maxTilesY)
8421 {
8422 num974 = Main.maxTilesY - 2;
8423 }
8424 if (Main.tile[num973 - 1, num974].active() && Main.tile[num973 - 1, num974].type == 0 && Main.tile[num973 + 1, num974].active() && Main.tile[num973 + 1, num974].type == 0 && Main.tile[num973, num974 - 1].active() && Main.tile[num973, num974 - 1].type == 0 && Main.tile[num973, num974 + 1].active() && Main.tile[num973, num974 + 1].type == 0)
8425 {
8426 Main.tile[num973, num974].active(active: true);
8427 Main.tile[num973, num974].type = 2;
8428 }
8429 }
8430 });
8431 AddGenerationPass(new JunglePass());
8432 AddGenerationPass("Mud Caves To Grass", delegate(GenerationProgress progress, GameConfiguration passConfig)
8433 {
8434 progress.Message = Lang.gen[77].Value;
8435 NotTheBees();
8436 for (int num966 = 0; num966 < Main.maxTilesX; num966++)
8437 {
8438 for (int num967 = 0; num967 < Main.maxTilesY; num967++)
8439 {
8440 if (Main.tile[num966, num967].active())
8441 {
8442 grassSpread = 0;
8443 SpreadGrass(num966, num967, 59, 60);
8444 }
8445 progress.Set(0.2 * ((double)(num966 * Main.maxTilesY + num967) / (double)(Main.maxTilesX * Main.maxTilesY)));
8446 }
8447 }
8448 SmallConsecutivesFound = 0;
8449 SmallConsecutivesEliminated = 0;
8450 double num968 = Main.maxTilesX - 20;
8451 for (int num969 = 10; num969 < Main.maxTilesX - 10; num969++)
8452 {
8453 ScanTileColumnAndRemoveClumps(num969);
8454 double num970 = (double)(num969 - 10) / num968;
8455 progress.Set(0.2 + num970 * 0.8);
8456 }
8457 });
8458 AddGenerationPass("Full Desert", delegate(GenerationProgress progress, GameConfiguration passConfig)
8459 {
8460 progress.Message = Lang.gen[78].Value;
8461 Main.tileSolid[484] = false;
8462 int num958 = 0;
8463 int num959 = GenVars.dungeonSide;
8464 int num960 = Main.maxTilesX / 2;
8465 int num961 = genRand.Next(num960) / 8;
8466 num961 += num960 / 8;
8467 int x16 = num960 + num961 * -num959;
8468 int num962 = 0;
8469 DesertBiome desertBiome = GenVars.configuration.CreateBiome<DesertBiome>();
8470 while (!desertBiome.Place(new Point(x16, (int)GenVars.worldSurfaceHigh + 25), GenVars.structures))
8471 {
8472 num961 = genRand.Next(num960) / 2;
8473 num961 += num960 / 8;
8474 num961 += genRand.Next(num962 / 12);
8475 x16 = num960 + num961 * -num959;
8476 if (++num962 > Main.maxTilesX / 4)
8477 {
8478 num959 *= -1;
8479 num962 = 0;
8480 num958++;
8481 if (num958 >= 2)
8482 {
8483 GenVars.skipDesertTileCheck = true;
8484 }
8485 }
8486 }
8487 if (remixWorldGen)
8488 {
8489 for (int num963 = 50; num963 < Main.maxTilesX - 50; num963++)
8490 {
8491 for (int num964 = (int)Main.rockLayer + genRand.Next(-1, 2); num964 < Main.maxTilesY - 50; num964++)
8492 {
8493 if ((Main.tile[num963, num964].type == 396 || Main.tile[num963, num964].type == 397 || Main.tile[num963, num964].type == 53) && !SolidTile(num963, num964 - 1))
8494 {
8495 for (int num965 = num964; num965 < num964 + genRand.Next(4, 7) && Main.tile[num963, num965 + 1].active() && (Main.tile[num963, num965].type == 396 || Main.tile[num963, num965].type == 397); num965++)
8496 {
8497 Main.tile[num963, num965].type = 53;
8498 }
8499 }
8500 }
8501 }
8502 }
8503 });
8504 AddGenerationPass("Floating Islands", delegate(GenerationProgress progress, GameConfiguration passConfig)
8505 {
8506 GenVars.numIslandHouses = 0;
8507 GenVars.skyIslandHouseCount = 0;
8508 progress.Message = Lang.gen[12].Value;
8509 int num948 = (int)((double)Main.maxTilesX * 0.0008);
8510 int num949 = 0;
8511 double num950 = num948 + GenVars.skyLakes;
8512 for (int num951 = 0; (double)num951 < num950; num951++)
8513 {
8514 progress.Set((double)num951 / num950);
8515 int num952 = Main.maxTilesX;
8516 while (--num952 > 0)
8517 {
8518 bool flag57 = true;
8519 int num953 = genRand.Next((int)((double)Main.maxTilesX * 0.1), (int)((double)Main.maxTilesX * 0.9));
8520 while (num953 > Main.maxTilesX / 2 - 150 && num953 < Main.maxTilesX / 2 + 150)
8521 {
8522 num953 = genRand.Next((int)((double)Main.maxTilesX * 0.1), (int)((double)Main.maxTilesX * 0.9));
8523 }
8524 for (int num954 = 0; num954 < GenVars.numIslandHouses; num954++)
8525 {
8526 if (num953 > GenVars.floatingIslandHouseX[num954] - 180 && num953 < GenVars.floatingIslandHouseX[num954] + 180)
8527 {
8528 flag57 = false;
8529 break;
8530 }
8531 }
8532 if (flag57)
8533 {
8534 flag57 = false;
8535 int num955 = 0;
8536 for (int num956 = 200; (double)num956 < Main.worldSurface; num956++)
8537 {
8538 if (Main.tile[num953, num956].active())
8539 {
8540 num955 = num956;
8541 flag57 = true;
8542 break;
8543 }
8544 }
8545 if (flag57)
8546 {
8547 int num957 = 0;
8548 num952 = -1;
8549 int val = genRand.Next(90, num955 - 100);
8550 val = Math.Min(val, (int)GenVars.worldSurfaceLow - 50);
8551 if (num949 >= num948)
8552 {
8553 GenVars.skyLake[GenVars.numIslandHouses] = true;
8554 CloudLake(num953, val);
8555 }
8556 else
8557 {
8558 GenVars.skyLake[GenVars.numIslandHouses] = false;
8559 if (drunkWorldGen && !remixWorldGen)
8560 {
8561 if (genRand.Next(2) == 0)
8562 {
8563 num957 = 3;
8564 SnowCloudIsland(num953, val);
8565 }
8566 else
8567 {
8568 num957 = 1;
8569 DesertCloudIsland(num953, val);
8570 }
8571 }
8572 else
8573 {
8574 if (remixWorldGen && drunkWorldGen)
8575 {
8576 num957 = ((GenVars.crimsonLeft && num953 < Main.maxTilesX / 2) ? 5 : ((GenVars.crimsonLeft || num953 <= Main.maxTilesX / 2) ? 4 : 5));
8577 }
8578 else if (getGoodWorldGen || remixWorldGen)
8579 {
8580 num957 = ((!crimson) ? 4 : 5);
8581 }
8582 else if (Main.tenthAnniversaryWorld)
8583 {
8584 num957 = 6;
8585 }
8586 CloudIsland(num953, val);
8587 }
8588 }
8589 GenVars.floatingIslandHouseX[GenVars.numIslandHouses] = num953;
8590 GenVars.floatingIslandHouseY[GenVars.numIslandHouses] = val;
8591 GenVars.floatingIslandStyle[GenVars.numIslandHouses] = num957;
8592 GenVars.numIslandHouses++;
8593 num949++;
8594 }
8595 }
8596 }
8597 }
8598 });
8599 AddGenerationPass("Mushroom Patches", delegate(GenerationProgress progress, GameConfiguration passConfig)
8600 {
8601 //IL_0287: Unknown result type (might be due to invalid IL or missing references)
8602 //IL_0292: Unknown result type (might be due to invalid IL or missing references)
8603 progress.Message = Lang.gen[13].Value;
8604 if (remixWorldGen)
8605 {
8606 for (int num927 = 10; num927 < Main.maxTilesX - 10; num927++)
8607 {
8608 for (int num928 = Main.maxTilesY + genRand.Next(3) - 350; num928 < Main.maxTilesY - 10; num928++)
8609 {
8610 if (Main.tile[num927, num928].type == 0)
8611 {
8612 Main.tile[num927, num928].type = 59;
8613 }
8614 }
8615 }
8616 }
8617 double num929 = (double)Main.maxTilesX / 700.0;
8618 if (num929 > (double)GenVars.maxMushroomBiomes)
8619 {
8620 num929 = GenVars.maxMushroomBiomes;
8621 }
8622 for (int num930 = 0; (double)num930 < num929; num930++)
8623 {
8624 int num931 = 0;
8625 bool flag56 = true;
8626 while (flag56)
8627 {
8628 int num932 = genRand.Next((int)((double)Main.maxTilesX * 0.2), (int)((double)Main.maxTilesX * 0.8));
8629 if (num931 > Main.maxTilesX / 4)
8630 {
8631 num932 = genRand.Next((int)((double)Main.maxTilesX * 0.25), (int)((double)Main.maxTilesX * 0.975));
8632 }
8633 int num933 = ((!remixWorldGen) ? genRand.Next((int)Main.rockLayer + 50, Main.maxTilesY - 300) : genRand.Next((int)Main.worldSurface + 50, (int)Main.rockLayer - 50));
8634 flag56 = false;
8635 int num934 = 100;
8636 int num935 = 500;
8637 for (int num936 = num932 - num934; num936 < num932 + num934; num936 += 3)
8638 {
8639 for (int num937 = num933 - num934; num937 < num933 + num934; num937 += 3)
8640 {
8641 if (InWorld(num936, num937))
8642 {
8643 if (Main.tile[num936, num937].type == 147 || Main.tile[num936, num937].type == 161 || Main.tile[num936, num937].type == 162 || Main.tile[num936, num937].type == 60 || Main.tile[num936, num937].type == 368 || Main.tile[num936, num937].type == 367)
8644 {
8645 flag56 = true;
8646 break;
8647 }
8648 if (GenVars.UndergroundDesertLocation.Contains(new Point(num936, num937)))
8649 {
8650 flag56 = true;
8651 break;
8652 }
8653 }
8654 else
8655 {
8656 flag56 = true;
8657 }
8658 }
8659 }
8660 if (!flag56)
8661 {
8662 for (int num938 = 0; num938 < GenVars.numMushroomBiomes; num938++)
8663 {
8664 if (Vector2D.Distance(GenVars.mushroomBiomesPosition[num938].ToVector2D(), new Vector2D((double)num932, (double)num933)) < (double)num935)
8665 {
8666 flag56 = true;
8667 }
8668 }
8669 }
8670 if (!flag56 && GenVars.numMushroomBiomes < GenVars.maxMushroomBiomes)
8671 {
8672 ShroomPatch(num932, num933);
8673 for (int num939 = 0; num939 < 5; num939++)
8674 {
8675 int i4 = num932 + genRand.Next(-40, 41);
8676 int j6 = num933 + genRand.Next(-40, 41);
8677 ShroomPatch(i4, j6);
8678 }
8679 GenVars.mushroomBiomesPosition[GenVars.numMushroomBiomes].X = num932;
8680 GenVars.mushroomBiomesPosition[GenVars.numMushroomBiomes].Y = num933;
8681 GenVars.numMushroomBiomes++;
8682 }
8683 num931++;
8684 if (num931 > Main.maxTilesX / 2)
8685 {
8686 break;
8687 }
8688 }
8689 }
8690 for (int num940 = 0; num940 < Main.maxTilesX; num940++)
8691 {
8692 progress.Set((double)num940 / (double)Main.maxTilesX);
8693 for (int num941 = (int)Main.worldSurface; num941 < Main.maxTilesY; num941++)
8694 {
8695 if (InWorld(num940, num941, 50) && Main.tile[num940, num941].active())
8696 {
8697 grassSpread = 0;
8698 SpreadGrass(num940, num941, 59, 70, repeat: false);
8699 }
8700 }
8701 }
8702 for (int num942 = 0; num942 < Main.maxTilesX; num942++)
8703 {
8704 for (int num943 = (int)Main.worldSurface; num943 < Main.maxTilesY; num943++)
8705 {
8706 if (Main.tile[num942, num943].active() && Main.tile[num942, num943].type == 70)
8707 {
8708 int type10 = 59;
8709 for (int num944 = num942 - 1; num944 <= num942 + 1; num944++)
8710 {
8711 for (int num945 = num943 - 1; num945 <= num943 + 1; num945++)
8712 {
8713 if (Main.tile[num944, num945].active())
8714 {
8715 if (!Main.tile[num944 - 1, num945].active() && !Main.tile[num944 + 1, num945].active())
8716 {
8717 KillTile(num944, num945);
8718 }
8719 else if (!Main.tile[num944, num945 - 1].active() && !Main.tile[num944, num945 + 1].active())
8720 {
8721 KillTile(num944, num945);
8722 }
8723 }
8724 else if (Main.tile[num944 - 1, num945].active() && Main.tile[num944 + 1, num945].active())
8725 {
8726 PlaceTile(num944, num945, type10);
8727 if (Main.tile[num944 - 1, num943].type == 70)
8728 {
8729 Main.tile[num944 - 1, num943].type = 59;
8730 }
8731 if (Main.tile[num944 + 1, num943].type == 70)
8732 {
8733 Main.tile[num944 + 1, num943].type = 59;
8734 }
8735 }
8736 else if (Main.tile[num944, num945 - 1].active() && Main.tile[num944, num945 + 1].active())
8737 {
8738 PlaceTile(num944, num945, type10);
8739 if (Main.tile[num944, num943 - 1].type == 70)
8740 {
8741 Main.tile[num944, num943 - 1].type = 59;
8742 }
8743 if (Main.tile[num944, num943 + 1].type == 70)
8744 {
8745 Main.tile[num944, num943 + 1].type = 59;
8746 }
8747 }
8748 }
8749 }
8750 if (genRand.Next(4) == 0)
8751 {
8752 int num946 = num942 + genRand.Next(-20, 21);
8753 int num947 = num943 + genRand.Next(-20, 21);
8754 if (InWorld(num946, num947) && Main.tile[num946, num947].type == 59)
8755 {
8756 Main.tile[num946, num947].type = 70;
8757 }
8758 }
8759 }
8760 }
8761 }
8762 });
8763 AddGenerationPass("Marble", delegate(GenerationProgress progress, GameConfiguration passConfig)
8764 {
8765 progress.Message = Lang.gen[80].Value;
8766 int num922 = passConfig.Get<WorldGenRange>("Count").GetRandom(genRand);
8767 double num923 = (double)(Main.maxTilesX - 160) / (double)num922;
8768 MarbleBiome marbleBiome = GenVars.configuration.CreateBiome<MarbleBiome>();
8769 int num924 = 0;
8770 int num925 = 0;
8771 while (num925 < num922)
8772 {
8773 double num926 = (double)num925 / (double)num922;
8774 progress.Set(num926);
8775 Point origin4 = RandomRectanglePoint((int)(num926 * (double)(Main.maxTilesX - 160)) + 80, (int)GenVars.rockLayer + 20, (int)num923, Main.maxTilesY - ((int)GenVars.rockLayer + 40) - 200);
8776 if (remixWorldGen)
8777 {
8778 origin4 = RandomRectanglePoint((int)(num926 * (double)(Main.maxTilesX - 160)) + 80, (int)GenVars.worldSurface + 100, (int)num923, (int)GenVars.rockLayer - (int)GenVars.worldSurface - 100);
8779 }
8780 while ((double)origin4.X > (double)Main.maxTilesX * 0.45 && (double)origin4.X < (double)Main.maxTilesX * 0.55)
8781 {
8782 origin4.X = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
8783 }
8784 num924++;
8785 if (marbleBiome.Place(origin4, GenVars.structures))
8786 {
8787 num925++;
8788 num924 = 0;
8789 }
8790 else if (num924 > Main.maxTilesX * 10)
8791 {
8792 num922 = num925;
8793 num925++;
8794 num924 = 0;
8795 }
8796 }
8797 });
8798 AddGenerationPass("Granite", delegate(GenerationProgress progress, GameConfiguration passConfig)
8799 {
8800 progress.Message = Lang.gen[81].Value;
8801 int num916 = passConfig.Get<WorldGenRange>("Count").GetRandom(genRand);
8802 double num917 = (double)(Main.maxTilesX - 200) / (double)num916;
8803 List<Point> list2 = new List<Point>(num916);
8804 int num918 = 0;
8805 int num919 = 0;
8806 while (num919 < num916)
8807 {
8808 double num920 = (double)num919 / (double)num916;
8809 progress.Set(num920);
8810 Point point3 = RandomRectanglePoint((int)(num920 * (double)(Main.maxTilesX - 200)) + 100, (int)GenVars.rockLayer + 20, (int)num917, Main.maxTilesY - ((int)GenVars.rockLayer + 40) - 200);
8811 if (remixWorldGen)
8812 {
8813 point3 = RandomRectanglePoint((int)(num920 * (double)(Main.maxTilesX - 200)) + 100, (int)GenVars.worldSurface + 100, (int)num917, (int)GenVars.rockLayer - (int)GenVars.worldSurface - 100);
8814 }
8815 while ((double)point3.X > (double)Main.maxTilesX * 0.45 && (double)point3.X < (double)Main.maxTilesX * 0.55)
8816 {
8817 point3.X = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
8818 }
8819 num918++;
8820 if (GraniteBiome.CanPlace(point3, GenVars.structures))
8821 {
8822 list2.Add(point3);
8823 num919++;
8824 }
8825 else if (num918 > Main.maxTilesX * 10)
8826 {
8827 num916 = num919;
8828 num919++;
8829 num918 = 0;
8830 }
8831 }
8832 GraniteBiome graniteBiome = GenVars.configuration.CreateBiome<GraniteBiome>();
8833 for (int num921 = 0; num921 < num916; num921++)
8834 {
8835 graniteBiome.Place(list2[num921], GenVars.structures);
8836 }
8837 });
8838 AddGenerationPass("Dirt To Mud", delegate(GenerationProgress progress, GameConfiguration passConfig)
8839 {
8840 progress.Message = Lang.gen[14].Value;
8841 double num914 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.001;
8842 for (int num915 = 0; (double)num915 < num914; num915++)
8843 {
8844 progress.Set((double)num915 / num914);
8845 if (remixWorldGen)
8846 {
8847 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.worldSurface, (int)GenVars.rockLayerLow), genRand.Next(2, 6), genRand.Next(2, 40), 59, addTile: false, 0.0, 0.0, noYChange: false, overRide: true, 53);
8848 }
8849 else
8850 {
8851 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(2, 6), genRand.Next(2, 40), 59, addTile: false, 0.0, 0.0, noYChange: false, overRide: true, 53);
8852 }
8853 }
8854 });
8855 AddGenerationPass("Silt", delegate(GenerationProgress progress, GameConfiguration passConfig)
8856 {
8857 progress.Message = Lang.gen[15].Value;
8858 for (int num908 = 0; num908 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0001); num908++)
8859 {
8860 int num909 = genRand.Next(0, Main.maxTilesX);
8861 int num910 = genRand.Next((int)GenVars.rockLayerHigh, Main.maxTilesY);
8862 if (remixWorldGen)
8863 {
8864 num910 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
8865 }
8866 if (Main.tile[num909, num910].wall != 187 && Main.tile[num909, num910].wall != 216)
8867 {
8868 TileRunner(num909, num910, genRand.Next(5, 12), genRand.Next(15, 50), 123);
8869 }
8870 }
8871 for (int num911 = 0; num911 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0005); num911++)
8872 {
8873 int num912 = genRand.Next(0, Main.maxTilesX);
8874 int num913 = genRand.Next((int)GenVars.rockLayerHigh, Main.maxTilesY);
8875 if (remixWorldGen)
8876 {
8877 num913 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
8878 }
8879 if (Main.tile[num912, num913].wall != 187 && Main.tile[num912, num913].wall != 216)
8880 {
8881 TileRunner(num912, num913, genRand.Next(2, 5), genRand.Next(2, 5), 123);
8882 }
8883 }
8884 });
8885 AddGenerationPass("Shinies", delegate(GenerationProgress progress, GameConfiguration passConfig)
8886 {
8887 progress.Message = Lang.gen[16].Value;
8888 if (remixWorldGen)
8889 {
8890 for (int num878 = 0; num878 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 6E-05); num878++)
8891 {
8892 if (drunkWorldGen)
8893 {
8894 if (genRand.Next(2) == 0)
8895 {
8896 GenVars.copper = 7;
8897 }
8898 else
8899 {
8900 GenVars.copper = 166;
8901 }
8902 }
8903 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh), genRand.Next(3, 6), genRand.Next(2, 6), GenVars.copper);
8904 }
8905 for (int num879 = 0; num879 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 8E-05); num879++)
8906 {
8907 if (drunkWorldGen)
8908 {
8909 if (genRand.Next(2) == 0)
8910 {
8911 GenVars.copper = 7;
8912 }
8913 else
8914 {
8915 GenVars.copper = 166;
8916 }
8917 }
8918 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh), genRand.Next(3, 7), genRand.Next(3, 7), GenVars.copper);
8919 }
8920 for (int num880 = 0; num880 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0002); num880++)
8921 {
8922 if (drunkWorldGen)
8923 {
8924 if (genRand.Next(2) == 0)
8925 {
8926 GenVars.copper = 7;
8927 }
8928 else
8929 {
8930 GenVars.copper = 166;
8931 }
8932 }
8933 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.copper);
8934 }
8935 for (int num881 = 0; num881 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 3E-05); num881++)
8936 {
8937 if (drunkWorldGen)
8938 {
8939 if (genRand.Next(2) == 0)
8940 {
8941 GenVars.iron = 6;
8942 }
8943 else
8944 {
8945 GenVars.iron = 167;
8946 }
8947 }
8948 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh), genRand.Next(3, 7), genRand.Next(2, 5), GenVars.iron);
8949 }
8950 for (int num882 = 0; num882 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 8E-05); num882++)
8951 {
8952 if (drunkWorldGen)
8953 {
8954 if (genRand.Next(2) == 0)
8955 {
8956 GenVars.iron = 6;
8957 }
8958 else
8959 {
8960 GenVars.iron = 167;
8961 }
8962 }
8963 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh), genRand.Next(3, 6), genRand.Next(3, 6), GenVars.iron);
8964 }
8965 for (int num883 = 0; num883 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0002); num883++)
8966 {
8967 if (drunkWorldGen)
8968 {
8969 if (genRand.Next(2) == 0)
8970 {
8971 GenVars.iron = 6;
8972 }
8973 else
8974 {
8975 GenVars.iron = 167;
8976 }
8977 }
8978 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.iron);
8979 }
8980 for (int num884 = 0; num884 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.6E-05); num884++)
8981 {
8982 if (drunkWorldGen)
8983 {
8984 if (genRand.Next(2) == 0)
8985 {
8986 GenVars.silver = 9;
8987 }
8988 else
8989 {
8990 GenVars.silver = 168;
8991 }
8992 }
8993 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer - 100, Main.maxTilesY - 250), genRand.Next(3, 6), genRand.Next(3, 6), GenVars.silver);
8994 }
8995 for (int num885 = 0; num885 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00015); num885++)
8996 {
8997 if (drunkWorldGen)
8998 {
8999 if (genRand.Next(2) == 0)
9000 {
9001 GenVars.silver = 9;
9002 }
9003 else
9004 {
9005 GenVars.silver = 168;
9006 }
9007 }
9008 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.worldSurface, (int)Main.rockLayer), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.silver);
9009 }
9010 for (int num886 = 0; num886 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00017); num886++)
9011 {
9012 if (drunkWorldGen)
9013 {
9014 if (genRand.Next(2) == 0)
9015 {
9016 GenVars.silver = 9;
9017 }
9018 else
9019 {
9020 GenVars.silver = 168;
9021 }
9022 }
9023 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(0, (int)GenVars.worldSurfaceLow), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.silver);
9024 }
9025 for (int num887 = 0; num887 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00012); num887++)
9026 {
9027 if (drunkWorldGen)
9028 {
9029 if (genRand.Next(2) == 0)
9030 {
9031 GenVars.gold = 8;
9032 }
9033 else
9034 {
9035 GenVars.gold = 169;
9036 }
9037 }
9038 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.worldSurface, (int)Main.rockLayer), genRand.Next(4, 8), genRand.Next(4, 8), GenVars.gold);
9039 }
9040 for (int num888 = 0; num888 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00012); num888++)
9041 {
9042 if (drunkWorldGen)
9043 {
9044 if (genRand.Next(2) == 0)
9045 {
9046 GenVars.gold = 8;
9047 }
9048 else
9049 {
9050 GenVars.gold = 169;
9051 }
9052 }
9053 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(0, (int)GenVars.worldSurfaceLow - 20), genRand.Next(4, 8), genRand.Next(4, 8), GenVars.gold);
9054 }
9055 if (drunkWorldGen)
9056 {
9057 for (int num889 = 0; num889 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.25E-05 / 2.0); num889++)
9058 {
9059 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer, Main.maxTilesY), genRand.Next(3, 6), genRand.Next(4, 8), 204);
9060 }
9061 for (int num890 = 0; num890 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.25E-05 / 2.0); num890++)
9062 {
9063 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer, Main.maxTilesY), genRand.Next(3, 6), genRand.Next(4, 8), 22);
9064 }
9065 }
9066 if (crimson)
9067 {
9068 for (int num891 = 0; num891 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 4.25E-05); num891++)
9069 {
9070 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.worldSurface, (int)Main.rockLayer), genRand.Next(3, 6), genRand.Next(4, 8), 204);
9071 }
9072 }
9073 else
9074 {
9075 for (int num892 = 0; num892 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 4.25E-05); num892++)
9076 {
9077 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.worldSurface, (int)Main.rockLayer), genRand.Next(3, 6), genRand.Next(4, 8), 22);
9078 }
9079 }
9080 }
9081 else
9082 {
9083 for (int num893 = 0; num893 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 6E-05); num893++)
9084 {
9085 if (drunkWorldGen)
9086 {
9087 if (genRand.Next(2) == 0)
9088 {
9089 GenVars.copper = 7;
9090 }
9091 else
9092 {
9093 GenVars.copper = 166;
9094 }
9095 }
9096 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh), genRand.Next(3, 6), genRand.Next(2, 6), GenVars.copper);
9097 }
9098 for (int num894 = 0; num894 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 8E-05); num894++)
9099 {
9100 if (drunkWorldGen)
9101 {
9102 if (genRand.Next(2) == 0)
9103 {
9104 GenVars.copper = 7;
9105 }
9106 else
9107 {
9108 GenVars.copper = 166;
9109 }
9110 }
9111 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh), genRand.Next(3, 7), genRand.Next(3, 7), GenVars.copper);
9112 }
9113 for (int num895 = 0; num895 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0002); num895++)
9114 {
9115 if (drunkWorldGen)
9116 {
9117 if (genRand.Next(2) == 0)
9118 {
9119 GenVars.copper = 7;
9120 }
9121 else
9122 {
9123 GenVars.copper = 166;
9124 }
9125 }
9126 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.copper);
9127 }
9128 for (int num896 = 0; num896 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 3E-05); num896++)
9129 {
9130 if (drunkWorldGen)
9131 {
9132 if (genRand.Next(2) == 0)
9133 {
9134 GenVars.iron = 6;
9135 }
9136 else
9137 {
9138 GenVars.iron = 167;
9139 }
9140 }
9141 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurfaceHigh), genRand.Next(3, 7), genRand.Next(2, 5), GenVars.iron);
9142 }
9143 for (int num897 = 0; num897 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 8E-05); num897++)
9144 {
9145 if (drunkWorldGen)
9146 {
9147 if (genRand.Next(2) == 0)
9148 {
9149 GenVars.iron = 6;
9150 }
9151 else
9152 {
9153 GenVars.iron = 167;
9154 }
9155 }
9156 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh), genRand.Next(3, 6), genRand.Next(3, 6), GenVars.iron);
9157 }
9158 for (int num898 = 0; num898 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0002); num898++)
9159 {
9160 if (drunkWorldGen)
9161 {
9162 if (genRand.Next(2) == 0)
9163 {
9164 GenVars.iron = 6;
9165 }
9166 else
9167 {
9168 GenVars.iron = 167;
9169 }
9170 }
9171 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.iron);
9172 }
9173 for (int num899 = 0; num899 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.6E-05); num899++)
9174 {
9175 if (drunkWorldGen)
9176 {
9177 if (genRand.Next(2) == 0)
9178 {
9179 GenVars.silver = 9;
9180 }
9181 else
9182 {
9183 GenVars.silver = 168;
9184 }
9185 }
9186 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.worldSurfaceHigh, (int)GenVars.rockLayerHigh), genRand.Next(3, 6), genRand.Next(3, 6), GenVars.silver);
9187 }
9188 for (int num900 = 0; num900 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00015); num900++)
9189 {
9190 if (drunkWorldGen)
9191 {
9192 if (genRand.Next(2) == 0)
9193 {
9194 GenVars.silver = 9;
9195 }
9196 else
9197 {
9198 GenVars.silver = 168;
9199 }
9200 }
9201 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.silver);
9202 }
9203 for (int num901 = 0; num901 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00017); num901++)
9204 {
9205 if (drunkWorldGen)
9206 {
9207 if (genRand.Next(2) == 0)
9208 {
9209 GenVars.silver = 9;
9210 }
9211 else
9212 {
9213 GenVars.silver = 168;
9214 }
9215 }
9216 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(0, (int)GenVars.worldSurfaceLow), genRand.Next(4, 9), genRand.Next(4, 8), GenVars.silver);
9217 }
9218 for (int num902 = 0; num902 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00012); num902++)
9219 {
9220 if (drunkWorldGen)
9221 {
9222 if (genRand.Next(2) == 0)
9223 {
9224 GenVars.gold = 8;
9225 }
9226 else
9227 {
9228 GenVars.gold = 169;
9229 }
9230 }
9231 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY), genRand.Next(4, 8), genRand.Next(4, 8), GenVars.gold);
9232 }
9233 for (int num903 = 0; num903 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.00012); num903++)
9234 {
9235 if (drunkWorldGen)
9236 {
9237 if (genRand.Next(2) == 0)
9238 {
9239 GenVars.gold = 8;
9240 }
9241 else
9242 {
9243 GenVars.gold = 169;
9244 }
9245 }
9246 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(0, (int)GenVars.worldSurfaceLow - 20), genRand.Next(4, 8), genRand.Next(4, 8), GenVars.gold);
9247 }
9248 if (drunkWorldGen)
9249 {
9250 for (int num904 = 0; num904 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.25E-05 / 2.0); num904++)
9251 {
9252 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer, Main.maxTilesY), genRand.Next(3, 6), genRand.Next(4, 8), 204);
9253 }
9254 for (int num905 = 0; num905 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.25E-05 / 2.0); num905++)
9255 {
9256 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer, Main.maxTilesY), genRand.Next(3, 6), genRand.Next(4, 8), 22);
9257 }
9258 }
9259 if (crimson)
9260 {
9261 for (int num906 = 0; num906 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.25E-05); num906++)
9262 {
9263 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer, Main.maxTilesY), genRand.Next(3, 6), genRand.Next(4, 8), 204);
9264 }
9265 }
9266 else
9267 {
9268 for (int num907 = 0; num907 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 2.25E-05); num907++)
9269 {
9270 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next((int)Main.rockLayer, Main.maxTilesY), genRand.Next(3, 6), genRand.Next(4, 8), 22);
9271 }
9272 }
9273 }
9274 });
9275 AddGenerationPass("Webs", delegate(GenerationProgress progress, GameConfiguration passConfig)
9276 {
9277 progress.Message = Lang.gen[17].Value;
9278 for (int num874 = 0; num874 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0006); num874++)
9279 {
9280 int num875 = genRand.Next(20, Main.maxTilesX - 20);
9281 int num876 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY - 20);
9282 if (num874 < GenVars.numMCaves)
9283 {
9284 num875 = GenVars.mCaveX[num874];
9285 num876 = GenVars.mCaveY[num874];
9286 }
9287 if (!Main.tile[num875, num876].active() && ((double)num876 > Main.worldSurface || Main.tile[num875, num876].wall > 0))
9288 {
9289 while (!Main.tile[num875, num876].active() && num876 > (int)GenVars.worldSurfaceLow)
9290 {
9291 num876--;
9292 }
9293 num876++;
9294 int num877 = 1;
9295 if (genRand.Next(2) == 0)
9296 {
9297 num877 = -1;
9298 }
9299 for (; !Main.tile[num875, num876].active() && num875 > 10 && num875 < Main.maxTilesX - 10; num875 += num877)
9300 {
9301 }
9302 num875 -= num877;
9303 if ((double)num876 > Main.worldSurface || Main.tile[num875, num876].wall > 0)
9304 {
9305 TileRunner(num875, num876, genRand.Next(4, 11), genRand.Next(2, 4), 51, addTile: true, num877, -1.0, noYChange: false, overRide: false);
9306 }
9307 }
9308 }
9309 });
9310 AddGenerationPass("Underworld", delegate(GenerationProgress progress, GameConfiguration passConfig)
9311 {
9312 progress.Message = Lang.gen[18].Value;
9313 progress.Set(0.0);
9314 int num838 = Main.maxTilesY - genRand.Next(150, 190);
9315 for (int num839 = 0; num839 < Main.maxTilesX; num839++)
9316 {
9317 num838 += genRand.Next(-3, 4);
9318 if (num838 < Main.maxTilesY - 190)
9319 {
9320 num838 = Main.maxTilesY - 190;
9321 }
9322 if (num838 > Main.maxTilesY - 160)
9323 {
9324 num838 = Main.maxTilesY - 160;
9325 }
9326 for (int num840 = num838 - 20 - genRand.Next(3); num840 < Main.maxTilesY; num840++)
9327 {
9328 if (num840 >= num838)
9329 {
9330 Main.tile[num839, num840].active(active: false);
9331 Main.tile[num839, num840].lava(lava: false);
9332 Main.tile[num839, num840].liquid = 0;
9333 }
9334 else
9335 {
9336 Main.tile[num839, num840].type = 57;
9337 }
9338 }
9339 }
9340 int num841 = Main.maxTilesY - genRand.Next(40, 70);
9341 for (int num842 = 10; num842 < Main.maxTilesX - 10; num842++)
9342 {
9343 num841 += genRand.Next(-10, 11);
9344 if (num841 > Main.maxTilesY - 60)
9345 {
9346 num841 = Main.maxTilesY - 60;
9347 }
9348 if (num841 < Main.maxTilesY - 100)
9349 {
9350 num841 = Main.maxTilesY - 120;
9351 }
9352 for (int num843 = num841; num843 < Main.maxTilesY - 10; num843++)
9353 {
9354 if (!Main.tile[num842, num843].active())
9355 {
9356 Main.tile[num842, num843].lava(lava: true);
9357 Main.tile[num842, num843].liquid = byte.MaxValue;
9358 }
9359 }
9360 }
9361 for (int num844 = 0; num844 < Main.maxTilesX; num844++)
9362 {
9363 if (genRand.Next(50) == 0)
9364 {
9365 int num845 = Main.maxTilesY - 65;
9366 while (!Main.tile[num844, num845].active() && num845 > Main.maxTilesY - 135)
9367 {
9368 num845--;
9369 }
9370 TileRunner(genRand.Next(0, Main.maxTilesX), num845 + genRand.Next(20, 50), genRand.Next(15, 20), 1000, 57, addTile: true, 0.0, genRand.Next(1, 3), noYChange: true);
9371 }
9372 }
9373 Liquid.QuickWater(-2);
9374 for (int num846 = 0; num846 < Main.maxTilesX; num846++)
9375 {
9376 double num847 = (double)num846 / (double)(Main.maxTilesX - 1);
9377 progress.Set(num847 / 2.0 + 0.5);
9378 if (genRand.Next(13) == 0)
9379 {
9380 int num848 = Main.maxTilesY - 65;
9381 while ((Main.tile[num846, num848].liquid > 0 || Main.tile[num846, num848].active()) && num848 > Main.maxTilesY - 140)
9382 {
9383 num848--;
9384 }
9385 if ((!drunkWorldGen && !remixWorldGen) || genRand.Next(3) == 0 || !((double)num846 > (double)Main.maxTilesX * 0.4) || !((double)num846 < (double)Main.maxTilesX * 0.6))
9386 {
9387 TileRunner(num846, num848 - genRand.Next(2, 5), genRand.Next(5, 30), 1000, 57, addTile: true, 0.0, genRand.Next(1, 3), noYChange: true);
9388 }
9389 double num849 = genRand.Next(1, 3);
9390 if (genRand.Next(3) == 0)
9391 {
9392 num849 *= 0.5;
9393 }
9394 if ((!drunkWorldGen && !remixWorldGen) || genRand.Next(3) == 0 || !((double)num846 > (double)Main.maxTilesX * 0.4) || !((double)num846 < (double)Main.maxTilesX * 0.6))
9395 {
9396 if (genRand.Next(2) == 0)
9397 {
9398 TileRunner(num846, num848 - genRand.Next(2, 5), (int)((double)genRand.Next(5, 15) * num849), (int)((double)genRand.Next(10, 15) * num849), 57, addTile: true, 1.0, 0.3);
9399 }
9400 if (genRand.Next(2) == 0)
9401 {
9402 num849 = genRand.Next(1, 3);
9403 TileRunner(num846, num848 - genRand.Next(2, 5), (int)((double)genRand.Next(5, 15) * num849), (int)((double)genRand.Next(10, 15) * num849), 57, addTile: true, -1.0, 0.3);
9404 }
9405 }
9406 TileRunner(num846 + genRand.Next(-10, 10), num848 + genRand.Next(-10, 10), genRand.Next(5, 15), genRand.Next(5, 10), -2, addTile: false, genRand.Next(-1, 3), genRand.Next(-1, 3));
9407 if (genRand.Next(3) == 0)
9408 {
9409 TileRunner(num846 + genRand.Next(-10, 10), num848 + genRand.Next(-10, 10), genRand.Next(10, 30), genRand.Next(10, 20), -2, addTile: false, genRand.Next(-1, 3), genRand.Next(-1, 3));
9410 }
9411 if (genRand.Next(5) == 0)
9412 {
9413 TileRunner(num846 + genRand.Next(-15, 15), num848 + genRand.Next(-15, 10), genRand.Next(15, 30), genRand.Next(5, 20), -2, addTile: false, genRand.Next(-1, 3), genRand.Next(-1, 3));
9414 }
9415 }
9416 }
9417 for (int num850 = 0; num850 < Main.maxTilesX; num850++)
9418 {
9419 TileRunner(genRand.Next(20, Main.maxTilesX - 20), genRand.Next(Main.maxTilesY - 180, Main.maxTilesY - 10), genRand.Next(2, 7), genRand.Next(2, 7), -2);
9420 }
9421 if (drunkWorldGen || remixWorldGen)
9422 {
9423 for (int num851 = 0; num851 < Main.maxTilesX * 2; num851++)
9424 {
9425 TileRunner(genRand.Next((int)((double)Main.maxTilesX * 0.35), (int)((double)Main.maxTilesX * 0.65)), genRand.Next(Main.maxTilesY - 180, Main.maxTilesY - 10), genRand.Next(5, 20), genRand.Next(5, 10), -2);
9426 }
9427 }
9428 for (int num852 = 0; num852 < Main.maxTilesX; num852++)
9429 {
9430 if (!Main.tile[num852, Main.maxTilesY - 145].active())
9431 {
9432 Main.tile[num852, Main.maxTilesY - 145].liquid = byte.MaxValue;
9433 Main.tile[num852, Main.maxTilesY - 145].lava(lava: true);
9434 }
9435 if (!Main.tile[num852, Main.maxTilesY - 144].active())
9436 {
9437 Main.tile[num852, Main.maxTilesY - 144].liquid = byte.MaxValue;
9438 Main.tile[num852, Main.maxTilesY - 144].lava(lava: true);
9439 }
9440 }
9441 for (int num853 = 0; num853 < (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0008); num853++)
9442 {
9443 TileRunner(genRand.Next(0, Main.maxTilesX), genRand.Next(Main.maxTilesY - 140, Main.maxTilesY), genRand.Next(2, 7), genRand.Next(3, 7), 58);
9444 }
9445 if (remixWorldGen)
9446 {
9447 int num854 = (int)((double)Main.maxTilesX * 0.38);
9448 int num855 = (int)((double)Main.maxTilesX * 0.62);
9449 int num856 = num854;
9450 int num857 = Main.maxTilesY - 1;
9451 int num858 = Main.maxTilesY - 135;
9452 int num859 = Main.maxTilesY - 160;
9453 bool flag55 = false;
9454 Liquid.QuickWater(-2);
9455 for (; num857 < Main.maxTilesY - 1 || num856 < num855; num856++)
9456 {
9457 if (!flag55)
9458 {
9459 num857 -= genRand.Next(1, 4);
9460 if (num857 < num858)
9461 {
9462 flag55 = true;
9463 }
9464 }
9465 else if (num856 >= num855)
9466 {
9467 num857 += genRand.Next(1, 4);
9468 if (num857 > Main.maxTilesY - 1)
9469 {
9470 num857 = Main.maxTilesY - 1;
9471 }
9472 }
9473 else
9474 {
9475 if ((num856 <= Main.maxTilesX / 2 - 5 || num856 >= Main.maxTilesX / 2 + 5) && genRand.Next(4) == 0)
9476 {
9477 if (genRand.Next(3) == 0)
9478 {
9479 num857 += genRand.Next(-1, 2);
9480 }
9481 else if (genRand.Next(6) == 0)
9482 {
9483 num857 += genRand.Next(-2, 3);
9484 }
9485 else if (genRand.Next(8) == 0)
9486 {
9487 num857 += genRand.Next(-4, 5);
9488 }
9489 }
9490 if (num857 < num859)
9491 {
9492 num857 = num859;
9493 }
9494 if (num857 > num858)
9495 {
9496 num857 = num858;
9497 }
9498 }
9499 for (int num860 = num857; num860 > num857 - 20; num860--)
9500 {
9501 Main.tile[num856, num860].liquid = 0;
9502 }
9503 for (int num861 = num857; num861 < Main.maxTilesY; num861++)
9504 {
9505 Main.tile[num856, num861] = new Tile();
9506 Main.tile[num856, num861].active(active: true);
9507 Main.tile[num856, num861].type = 57;
9508 }
9509 }
9510 Liquid.QuickWater(-2);
9511 for (int num862 = num854; num862 < num855 + 15; num862++)
9512 {
9513 for (int num863 = Main.maxTilesY - 300; num863 < num858 + 20; num863++)
9514 {
9515 Main.tile[num862, num863].liquid = 0;
9516 if (Main.tile[num862, num863].type == 57 && Main.tile[num862, num863].active() && (!Main.tile[num862 - 1, num863 - 1].active() || !Main.tile[num862, num863 - 1].active() || !Main.tile[num862 + 1, num863 - 1].active() || !Main.tile[num862 - 1, num863].active() || !Main.tile[num862 + 1, num863].active() || !Main.tile[num862 - 1, num863 + 1].active() || !Main.tile[num862, num863 + 1].active() || !Main.tile[num862 + 1, num863 + 1].active()))
9517 {
9518 Main.tile[num862, num863].type = 633;
9519 }
9520 }
9521 }
9522 for (int num864 = num854; num864 < num855 + 15; num864++)
9523 {
9524 for (int num865 = Main.maxTilesY - 200; num865 < num858 + 20; num865++)
9525 {
9526 if (Main.tile[num864, num865].type == 633 && Main.tile[num864, num865].active() && !Main.tile[num864, num865 - 1].active() && genRand.Next(3) == 0)
9527 {
9528 TryGrowingTreeByType(634, num864, num865);
9529 }
9530 }
9531 }
9532 }
9533 else if (!drunkWorldGen)
9534 {
9535 for (int num866 = 25; num866 < Main.maxTilesX - 25; num866++)
9536 {
9537 if ((double)num866 < (double)Main.maxTilesX * 0.17 || (double)num866 > (double)Main.maxTilesX * 0.83)
9538 {
9539 for (int num867 = Main.maxTilesY - 300; num867 < Main.maxTilesY - 100 + genRand.Next(-1, 2); num867++)
9540 {
9541 if (Main.tile[num866, num867].type == 57 && Main.tile[num866, num867].active() && (!Main.tile[num866 - 1, num867 - 1].active() || !Main.tile[num866, num867 - 1].active() || !Main.tile[num866 + 1, num867 - 1].active() || !Main.tile[num866 - 1, num867].active() || !Main.tile[num866 + 1, num867].active() || !Main.tile[num866 - 1, num867 + 1].active() || !Main.tile[num866, num867 + 1].active() || !Main.tile[num866 + 1, num867 + 1].active()))
9542 {
9543 Main.tile[num866, num867].type = 633;
9544 }
9545 }
9546 }
9547 }
9548 for (int num868 = 25; num868 < Main.maxTilesX - 25; num868++)
9549 {
9550 if ((double)num868 < (double)Main.maxTilesX * 0.17 || (double)num868 > (double)Main.maxTilesX * 0.83)
9551 {
9552 for (int num869 = Main.maxTilesY - 200; num869 < Main.maxTilesY - 50; num869++)
9553 {
9554 if (Main.tile[num868, num869].type == 633 && Main.tile[num868, num869].active() && !Main.tile[num868, num869 - 1].active() && genRand.Next(3) == 0)
9555 {
9556 TryGrowingTreeByType(634, num868, num869);
9557 }
9558 }
9559 }
9560 }
9561 }
9562 AddHellHouses();
9563 if (drunkWorldGen)
9564 {
9565 for (int num870 = 25; num870 < Main.maxTilesX - 25; num870++)
9566 {
9567 for (int num871 = Main.maxTilesY - 300; num871 < Main.maxTilesY - 100 + genRand.Next(-1, 2); num871++)
9568 {
9569 if (Main.tile[num870, num871].type == 57 && Main.tile[num870, num871].active() && (!Main.tile[num870 - 1, num871 - 1].active() || !Main.tile[num870, num871 - 1].active() || !Main.tile[num870 + 1, num871 - 1].active() || !Main.tile[num870 - 1, num871].active() || !Main.tile[num870 + 1, num871].active() || !Main.tile[num870 - 1, num871 + 1].active() || !Main.tile[num870, num871 + 1].active() || !Main.tile[num870 + 1, num871 + 1].active()))
9570 {
9571 Main.tile[num870, num871].type = 633;
9572 }
9573 }
9574 }
9575 for (int num872 = 25; num872 < Main.maxTilesX - 25; num872++)
9576 {
9577 for (int num873 = Main.maxTilesY - 200; num873 < Main.maxTilesY - 50; num873++)
9578 {
9579 if (Main.tile[num872, num873].type == 633 && Main.tile[num872, num873].active() && !Main.tile[num872, num873 - 1].active() && genRand.Next(3) == 0)
9580 {
9581 TryGrowingTreeByType(634, num872, num873);
9582 }
9583 }
9584 }
9585 }
9586 });
9587 AddGenerationPass("Corruption", delegate(GenerationProgress progress, GameConfiguration passConfig)
9588 {
9589 int num778 = Main.maxTilesX;
9590 int num779 = 0;
9591 int num780 = Main.maxTilesX;
9592 int num781 = 0;
9593 for (int num782 = 0; num782 < Main.maxTilesX; num782++)
9594 {
9595 for (int num783 = 0; (double)num783 < Main.worldSurface; num783++)
9596 {
9597 if (Main.tile[num782, num783].active())
9598 {
9599 if (Main.tile[num782, num783].type == 60)
9600 {
9601 if (num782 < num778)
9602 {
9603 num778 = num782;
9604 }
9605 if (num782 > num779)
9606 {
9607 num779 = num782;
9608 }
9609 }
9610 else if (Main.tile[num782, num783].type == 147 || Main.tile[num782, num783].type == 161)
9611 {
9612 if (num782 < num780)
9613 {
9614 num780 = num782;
9615 }
9616 if (num782 > num781)
9617 {
9618 num781 = num782;
9619 }
9620 }
9621 }
9622 }
9623 }
9624 int num784 = 10;
9625 num778 -= num784;
9626 num779 += num784;
9627 num780 -= num784;
9628 num781 += num784;
9629 int num785 = 500;
9630 int num786 = 100;
9631 bool flag49 = crimson;
9632 double num787 = (double)Main.maxTilesX * 0.00045;
9633 if (remixWorldGen)
9634 {
9635 num787 *= 2.0;
9636 }
9637 else if (tenthAnniversaryWorldGen)
9638 {
9639 num785 *= 2;
9640 num786 *= 2;
9641 }
9642 if (drunkWorldGen)
9643 {
9644 flag49 = true;
9645 num787 /= 2.0;
9646 }
9647 if (flag49)
9648 {
9649 progress.Message = Lang.gen[72].Value;
9650 for (int num788 = 0; (double)num788 < num787; num788++)
9651 {
9652 int num789 = num780;
9653 int num790 = num781;
9654 int num791 = num778;
9655 int num792 = num779;
9656 double value15 = (double)num788 / num787;
9657 progress.Set(value15);
9658 bool flag50 = false;
9659 int num793 = 0;
9660 int num794 = 0;
9661 int num795 = 0;
9662 while (!flag50)
9663 {
9664 flag50 = true;
9665 int num796 = Main.maxTilesX / 2;
9666 int num797 = 200;
9667 if (drunkWorldGen)
9668 {
9669 num797 = 100;
9670 num793 = ((!GenVars.crimsonLeft) ? genRand.Next((int)((double)Main.maxTilesX * 0.5), Main.maxTilesX - num785) : genRand.Next(num785, (int)((double)Main.maxTilesX * 0.5)));
9671 }
9672 else
9673 {
9674 num793 = genRand.Next(num785, Main.maxTilesX - num785);
9675 }
9676 num794 = num793 - genRand.Next(200) - 100;
9677 num795 = num793 + genRand.Next(200) + 100;
9678 if (num794 < GenVars.evilBiomeBeachAvoidance)
9679 {
9680 num794 = GenVars.evilBiomeBeachAvoidance;
9681 }
9682 if (num795 > Main.maxTilesX - GenVars.evilBiomeBeachAvoidance)
9683 {
9684 num795 = Main.maxTilesX - GenVars.evilBiomeBeachAvoidance;
9685 }
9686 if (num793 < num794 + GenVars.evilBiomeAvoidanceMidFixer)
9687 {
9688 num793 = num794 + GenVars.evilBiomeAvoidanceMidFixer;
9689 }
9690 if (num793 > num795 - GenVars.evilBiomeAvoidanceMidFixer)
9691 {
9692 num793 = num795 - GenVars.evilBiomeAvoidanceMidFixer;
9693 }
9694 if (GenVars.dungeonSide < 0 && num794 < 400)
9695 {
9696 num794 = 400;
9697 }
9698 else if (GenVars.dungeonSide > 0 && num794 > Main.maxTilesX - 400)
9699 {
9700 num794 = Main.maxTilesX - 400;
9701 }
9702 if (num794 < GenVars.dungeonLocation + num786 && num795 > GenVars.dungeonLocation - num786)
9703 {
9704 flag50 = false;
9705 }
9706 if (!remixWorldGen)
9707 {
9708 if (!tenthAnniversaryWorldGen)
9709 {
9710 if (num793 > num796 - num797 && num793 < num796 + num797)
9711 {
9712 flag50 = false;
9713 }
9714 if (num794 > num796 - num797 && num794 < num796 + num797)
9715 {
9716 flag50 = false;
9717 }
9718 if (num795 > num796 - num797 && num795 < num796 + num797)
9719 {
9720 flag50 = false;
9721 }
9722 }
9723 if (num793 > GenVars.UndergroundDesertLocation.X && num793 < GenVars.UndergroundDesertLocation.X + GenVars.UndergroundDesertLocation.Width)
9724 {
9725 flag50 = false;
9726 }
9727 if (num794 > GenVars.UndergroundDesertLocation.X && num794 < GenVars.UndergroundDesertLocation.X + GenVars.UndergroundDesertLocation.Width)
9728 {
9729 flag50 = false;
9730 }
9731 if (num795 > GenVars.UndergroundDesertLocation.X && num795 < GenVars.UndergroundDesertLocation.X + GenVars.UndergroundDesertLocation.Width)
9732 {
9733 flag50 = false;
9734 }
9735 if (num794 < num790 && num795 > num789)
9736 {
9737 num789++;
9738 num790--;
9739 flag50 = false;
9740 }
9741 if (num794 < num792 && num795 > num791)
9742 {
9743 num791++;
9744 num792--;
9745 flag50 = false;
9746 }
9747 }
9748 }
9749 CrimStart(num793, (int)GenVars.worldSurfaceLow - 10);
9750 for (int num798 = num794; num798 < num795; num798++)
9751 {
9752 for (int num799 = (int)GenVars.worldSurfaceLow; (double)num799 < Main.worldSurface - 1.0; num799++)
9753 {
9754 if (Main.tile[num798, num799].active())
9755 {
9756 int num800 = num799 + genRand.Next(10, 14);
9757 for (int num801 = num799; num801 < num800; num801++)
9758 {
9759 if (Main.tile[num798, num801].type == 60 && num798 >= num794 + genRand.Next(5) && num798 < num795 - genRand.Next(5))
9760 {
9761 Main.tile[num798, num801].type = 662;
9762 }
9763 }
9764 break;
9765 }
9766 }
9767 }
9768 double num802 = Main.worldSurface + 40.0;
9769 for (int num803 = num794; num803 < num795; num803++)
9770 {
9771 num802 += (double)genRand.Next(-2, 3);
9772 if (num802 < Main.worldSurface + 30.0)
9773 {
9774 num802 = Main.worldSurface + 30.0;
9775 }
9776 if (num802 > Main.worldSurface + 50.0)
9777 {
9778 num802 = Main.worldSurface + 50.0;
9779 }
9780 bool flag51 = false;
9781 for (int num804 = (int)GenVars.worldSurfaceLow; (double)num804 < num802; num804++)
9782 {
9783 if (Main.tile[num803, num804].active())
9784 {
9785 if (Main.tile[num803, num804].type == 53 && num803 >= num794 + genRand.Next(5) && num803 <= num795 - genRand.Next(5))
9786 {
9787 Main.tile[num803, num804].type = 234;
9788 }
9789 if ((double)num804 < Main.worldSurface - 1.0 && !flag51)
9790 {
9791 if (Main.tile[num803, num804].type == 0)
9792 {
9793 grassSpread = 0;
9794 SpreadGrass(num803, num804, 0, 199);
9795 }
9796 else if (Main.tile[num803, num804].type == 59)
9797 {
9798 grassSpread = 0;
9799 SpreadGrass(num803, num804, 59, 662);
9800 }
9801 }
9802 flag51 = true;
9803 if (Main.tile[num803, num804].wall == 216)
9804 {
9805 Main.tile[num803, num804].wall = 218;
9806 }
9807 else if (Main.tile[num803, num804].wall == 187)
9808 {
9809 Main.tile[num803, num804].wall = 221;
9810 }
9811 if (Main.tile[num803, num804].type == 1)
9812 {
9813 if (num803 >= num794 + genRand.Next(5) && num803 <= num795 - genRand.Next(5))
9814 {
9815 Main.tile[num803, num804].type = 203;
9816 }
9817 }
9818 else if (Main.tile[num803, num804].type == 2)
9819 {
9820 Main.tile[num803, num804].type = 199;
9821 }
9822 else if (Main.tile[num803, num804].type == 60)
9823 {
9824 Main.tile[num803, num804].type = 662;
9825 }
9826 else if (Main.tile[num803, num804].type == 161)
9827 {
9828 Main.tile[num803, num804].type = 200;
9829 }
9830 else if (Main.tile[num803, num804].type == 396)
9831 {
9832 Main.tile[num803, num804].type = 401;
9833 }
9834 else if (Main.tile[num803, num804].type == 397)
9835 {
9836 Main.tile[num803, num804].type = 399;
9837 }
9838 }
9839 }
9840 }
9841 int num805 = genRand.Next(10, 15);
9842 for (int num806 = 0; num806 < num805; num806++)
9843 {
9844 int num807 = 0;
9845 bool flag52 = false;
9846 int num808 = 0;
9847 while (!flag52)
9848 {
9849 num807++;
9850 int num809 = genRand.Next(num794 - num808, num795 + num808);
9851 int num810 = genRand.Next((int)(Main.worldSurface - (double)(num808 / 2)), (int)(Main.worldSurface + 100.0 + (double)num808));
9852 while (oceanDepths(num809, num810))
9853 {
9854 num809 = genRand.Next(num794 - num808, num795 + num808);
9855 num810 = genRand.Next((int)(Main.worldSurface - (double)(num808 / 2)), (int)(Main.worldSurface + 100.0 + (double)num808));
9856 }
9857 if (num807 > 100)
9858 {
9859 num808++;
9860 num807 = 0;
9861 }
9862 if (!Main.tile[num809, num810].active())
9863 {
9864 for (; !Main.tile[num809, num810].active(); num810++)
9865 {
9866 }
9867 num810--;
9868 }
9869 else
9870 {
9871 while (Main.tile[num809, num810].active() && (double)num810 > Main.worldSurface)
9872 {
9873 num810--;
9874 }
9875 }
9876 if ((num808 > 10 || (Main.tile[num809, num810 + 1].active() && Main.tile[num809, num810 + 1].type == 203)) && !IsTileNearby(num809, num810, 26, 3))
9877 {
9878 Place3x2(num809, num810, 26, 1);
9879 if (Main.tile[num809, num810].type == 26)
9880 {
9881 flag52 = true;
9882 }
9883 }
9884 if (num808 > 100)
9885 {
9886 flag52 = true;
9887 }
9888 }
9889 }
9890 }
9891 CrimPlaceHearts();
9892 }
9893 if (drunkWorldGen)
9894 {
9895 flag49 = false;
9896 }
9897 if (!flag49)
9898 {
9899 progress.Message = Lang.gen[20].Value;
9900 for (int num811 = 0; (double)num811 < num787; num811++)
9901 {
9902 int num812 = num780;
9903 int num813 = num781;
9904 int num814 = num778;
9905 int num815 = num779;
9906 double value16 = (double)num811 / num787;
9907 progress.Set(value16);
9908 bool flag53 = false;
9909 int num816 = 0;
9910 int num817 = 0;
9911 int num818 = 0;
9912 while (!flag53)
9913 {
9914 flag53 = true;
9915 int num819 = Main.maxTilesX / 2;
9916 int num820 = 200;
9917 num816 = ((!drunkWorldGen) ? genRand.Next(num785, Main.maxTilesX - num785) : (GenVars.crimsonLeft ? genRand.Next((int)((double)Main.maxTilesX * 0.5), Main.maxTilesX - num785) : genRand.Next(num785, (int)((double)Main.maxTilesX * 0.5))));
9918 num817 = num816 - genRand.Next(200) - 100;
9919 num818 = num816 + genRand.Next(200) + 100;
9920 if (num817 < GenVars.evilBiomeBeachAvoidance)
9921 {
9922 num817 = GenVars.evilBiomeBeachAvoidance;
9923 }
9924 if (num818 > Main.maxTilesX - GenVars.evilBiomeBeachAvoidance)
9925 {
9926 num818 = Main.maxTilesX - GenVars.evilBiomeBeachAvoidance;
9927 }
9928 if (num816 < num817 + GenVars.evilBiomeAvoidanceMidFixer)
9929 {
9930 num816 = num817 + GenVars.evilBiomeAvoidanceMidFixer;
9931 }
9932 if (num816 > num818 - GenVars.evilBiomeAvoidanceMidFixer)
9933 {
9934 num816 = num818 - GenVars.evilBiomeAvoidanceMidFixer;
9935 }
9936 if (num817 < GenVars.dungeonLocation + num786 && num818 > GenVars.dungeonLocation - num786)
9937 {
9938 flag53 = false;
9939 }
9940 if (!remixWorldGen)
9941 {
9942 if (!tenthAnniversaryWorldGen)
9943 {
9944 if (num816 > num819 - num820 && num816 < num819 + num820)
9945 {
9946 flag53 = false;
9947 }
9948 if (num817 > num819 - num820 && num817 < num819 + num820)
9949 {
9950 flag53 = false;
9951 }
9952 if (num818 > num819 - num820 && num818 < num819 + num820)
9953 {
9954 flag53 = false;
9955 }
9956 }
9957 if (num816 > GenVars.UndergroundDesertLocation.X && num816 < GenVars.UndergroundDesertLocation.X + GenVars.UndergroundDesertLocation.Width)
9958 {
9959 flag53 = false;
9960 }
9961 if (num817 > GenVars.UndergroundDesertLocation.X && num817 < GenVars.UndergroundDesertLocation.X + GenVars.UndergroundDesertLocation.Width)
9962 {
9963 flag53 = false;
9964 }
9965 if (num818 > GenVars.UndergroundDesertLocation.X && num818 < GenVars.UndergroundDesertLocation.X + GenVars.UndergroundDesertLocation.Width)
9966 {
9967 flag53 = false;
9968 }
9969 if (num817 < num813 && num818 > num812)
9970 {
9971 num812++;
9972 num813--;
9973 flag53 = false;
9974 }
9975 if (num817 < num815 && num818 > num814)
9976 {
9977 num814++;
9978 num815--;
9979 flag53 = false;
9980 }
9981 }
9982 }
9983 int num821 = 0;
9984 for (int num822 = num817; num822 < num818; num822++)
9985 {
9986 if (num821 > 0)
9987 {
9988 num821--;
9989 }
9990 if (num822 == num816 || num821 == 0)
9991 {
9992 for (int num823 = (int)GenVars.worldSurfaceLow; (double)num823 < Main.worldSurface - 1.0; num823++)
9993 {
9994 if (Main.tile[num822, num823].active() || Main.tile[num822, num823].wall > 0)
9995 {
9996 if (num822 == num816)
9997 {
9998 num821 = 20;
9999 ChasmRunner(num822, num823, genRand.Next(150) + 150, makeOrb: true);
10000 }
10001 else if (genRand.Next(35) == 0 && num821 == 0)
10002 {
10003 num821 = 30;
10004 bool makeOrb = true;
10005 ChasmRunner(num822, num823, genRand.Next(50) + 50, makeOrb);
10006 }
10007 break;
10008 }
10009 }
10010 }
10011 for (int num824 = (int)GenVars.worldSurfaceLow; (double)num824 < Main.worldSurface - 1.0; num824++)
10012 {
10013 if (Main.tile[num822, num824].active())
10014 {
10015 int num825 = num824 + genRand.Next(10, 14);
10016 for (int num826 = num824; num826 < num825; num826++)
10017 {
10018 if (Main.tile[num822, num826].type == 60 && num822 >= num817 + genRand.Next(5) && num822 < num818 - genRand.Next(5))
10019 {
10020 Main.tile[num822, num826].type = 661;
10021 }
10022 }
10023 break;
10024 }
10025 }
10026 }
10027 double num827 = Main.worldSurface + 40.0;
10028 for (int num828 = num817; num828 < num818; num828++)
10029 {
10030 num827 += (double)genRand.Next(-2, 3);
10031 if (num827 < Main.worldSurface + 30.0)
10032 {
10033 num827 = Main.worldSurface + 30.0;
10034 }
10035 if (num827 > Main.worldSurface + 50.0)
10036 {
10037 num827 = Main.worldSurface + 50.0;
10038 }
10039 bool flag54 = false;
10040 for (int num829 = (int)GenVars.worldSurfaceLow; (double)num829 < num827; num829++)
10041 {
10042 if (Main.tile[num828, num829].active())
10043 {
10044 if (Main.tile[num828, num829].type == 53 && num828 >= num817 + genRand.Next(5) && num828 <= num818 - genRand.Next(5))
10045 {
10046 Main.tile[num828, num829].type = 112;
10047 }
10048 if ((double)num829 < Main.worldSurface - 1.0 && !flag54)
10049 {
10050 if (Main.tile[num828, num829].type == 0)
10051 {
10052 grassSpread = 0;
10053 SpreadGrass(num828, num829, 0, 23);
10054 }
10055 else if (Main.tile[num828, num829].type == 59)
10056 {
10057 grassSpread = 0;
10058 SpreadGrass(num828, num829, 59, 661);
10059 }
10060 }
10061 flag54 = true;
10062 if (Main.tile[num828, num829].wall == 216)
10063 {
10064 Main.tile[num828, num829].wall = 217;
10065 }
10066 else if (Main.tile[num828, num829].wall == 187)
10067 {
10068 Main.tile[num828, num829].wall = 220;
10069 }
10070 if (Main.tile[num828, num829].type == 1)
10071 {
10072 if (num828 >= num817 + genRand.Next(5) && num828 <= num818 - genRand.Next(5))
10073 {
10074 Main.tile[num828, num829].type = 25;
10075 }
10076 }
10077 else if (Main.tile[num828, num829].type == 2)
10078 {
10079 Main.tile[num828, num829].type = 23;
10080 }
10081 else if (Main.tile[num828, num829].type == 60)
10082 {
10083 Main.tile[num828, num829].type = 661;
10084 }
10085 else if (Main.tile[num828, num829].type == 161)
10086 {
10087 Main.tile[num828, num829].type = 163;
10088 }
10089 else if (Main.tile[num828, num829].type == 396)
10090 {
10091 Main.tile[num828, num829].type = 400;
10092 }
10093 else if (Main.tile[num828, num829].type == 397)
10094 {
10095 Main.tile[num828, num829].type = 398;
10096 }
10097 }
10098 }
10099 }
10100 for (int num830 = num817; num830 < num818; num830++)
10101 {
10102 for (int num831 = 0; num831 < Main.maxTilesY - 50; num831++)
10103 {
10104 if (Main.tile[num830, num831].active() && Main.tile[num830, num831].type == 31)
10105 {
10106 int num832 = num830 - 13;
10107 int num833 = num830 + 13;
10108 int num834 = num831 - 13;
10109 int num835 = num831 + 13;
10110 for (int num836 = num832; num836 < num833; num836++)
10111 {
10112 if (num836 > 10 && num836 < Main.maxTilesX - 10)
10113 {
10114 for (int num837 = num834; num837 < num835; num837++)
10115 {
10116 if (Math.Abs(num836 - num830) + Math.Abs(num837 - num831) < 9 + genRand.Next(11) && genRand.Next(3) != 0 && Main.tile[num836, num837].type != 31)
10117 {
10118 Main.tile[num836, num837].active(active: true);
10119 Main.tile[num836, num837].type = 25;
10120 if (Math.Abs(num836 - num830) <= 1 && Math.Abs(num837 - num831) <= 1)
10121 {
10122 Main.tile[num836, num837].active(active: false);
10123 }
10124 }
10125 if (Main.tile[num836, num837].type != 31 && Math.Abs(num836 - num830) <= 2 + genRand.Next(3) && Math.Abs(num837 - num831) <= 2 + genRand.Next(3))
10126 {
10127 Main.tile[num836, num837].active(active: false);
10128 }
10129 }
10130 }
10131 }
10132 }
10133 }
10134 }
10135 }
10136 }
10137 });
10138 AddGenerationPass("Lakes", delegate(GenerationProgress progress, GameConfiguration passConfig)
10139 {
10140 progress.Message = Lang.gen[19].Value;
10141 double num759 = (double)Main.maxTilesX / 4200.0;
10142 int num760 = genRand.Next((int)(num759 * 3.0), (int)(num759 * 6.0));
10143 for (int num761 = 0; num761 < num760; num761++)
10144 {
10145 int num762 = Main.maxTilesX / 4;
10146 if (GenVars.numLakes >= GenVars.maxLakes - 1)
10147 {
10148 break;
10149 }
10150 double value14 = (double)num761 / (double)num760;
10151 progress.Set(value14);
10152 while (num762 > 0)
10153 {
10154 bool flag48 = false;
10155 num762--;
10156 int num763 = genRand.Next(GenVars.lakesBeachAvoidance, Main.maxTilesX - GenVars.lakesBeachAvoidance);
10157 if (tenthAnniversaryWorldGen && !remixWorldGen)
10158 {
10159 num763 = genRand.Next((int)((double)Main.maxTilesX * 0.15), (int)((double)Main.maxTilesX * 0.85));
10160 }
10161 else
10162 {
10163 while ((double)num763 > (double)Main.maxTilesX * 0.45 && (double)num763 < (double)Main.maxTilesX * 0.55)
10164 {
10165 num763 = genRand.Next(GenVars.lakesBeachAvoidance, Main.maxTilesX - GenVars.lakesBeachAvoidance);
10166 }
10167 }
10168 for (int num764 = 0; num764 < GenVars.numLakes; num764++)
10169 {
10170 if (Math.Abs(num763 - GenVars.LakeX[num764]) < 150)
10171 {
10172 flag48 = true;
10173 break;
10174 }
10175 }
10176 for (int num765 = 0; num765 < GenVars.numMCaves; num765++)
10177 {
10178 if (Math.Abs(num763 - GenVars.mCaveX[num765]) < 100)
10179 {
10180 flag48 = true;
10181 break;
10182 }
10183 }
10184 for (int num766 = 0; num766 < GenVars.numTunnels; num766++)
10185 {
10186 if (Math.Abs(num763 - GenVars.tunnelX[num766]) < 100)
10187 {
10188 flag48 = true;
10189 break;
10190 }
10191 }
10192 if (!flag48)
10193 {
10194 int num767 = (int)GenVars.worldSurfaceLow - 20;
10195 while (!Main.tile[num763, num767].active())
10196 {
10197 num767++;
10198 if ((double)num767 >= Main.worldSurface || Main.tile[num763, num767].wall > 0)
10199 {
10200 flag48 = true;
10201 break;
10202 }
10203 }
10204 if (Main.tile[num763, num767].type == 53)
10205 {
10206 flag48 = true;
10207 }
10208 if (!flag48)
10209 {
10210 int num768 = 50;
10211 for (int num769 = num763 - num768; num769 <= num763 + num768; num769++)
10212 {
10213 for (int num770 = num767 - num768; num770 <= num767 + num768; num770++)
10214 {
10215 if (Main.tile[num769, num770].type == 203 || Main.tile[num769, num770].type == 25)
10216 {
10217 flag48 = true;
10218 break;
10219 }
10220 }
10221 }
10222 if (!flag48)
10223 {
10224 int num771 = num767;
10225 num768 = 20;
10226 while (!SolidTile(num763 - num768, num767) || !SolidTile(num763 + num768, num767))
10227 {
10228 num767++;
10229 if ((double)num767 > Main.worldSurface - 50.0)
10230 {
10231 flag48 = true;
10232 }
10233 }
10234 if (num767 - num771 <= 10)
10235 {
10236 num768 = 60;
10237 for (int num772 = num763 - num768; num772 <= num763 + num768; num772++)
10238 {
10239 int num773 = num767 - 20;
10240 if (Main.tile[num772, num773].active() || Main.tile[num772, num773].wall > 0)
10241 {
10242 flag48 = true;
10243 }
10244 }
10245 if (!flag48)
10246 {
10247 int num774 = 0;
10248 for (int num775 = num763 - num768; num775 <= num763 + num768; num775++)
10249 {
10250 for (int num776 = num767; num776 <= num767 + num768 * 2; num776++)
10251 {
10252 if (SolidTile(num775, num776))
10253 {
10254 num774++;
10255 }
10256 }
10257 }
10258 int num777 = (num768 * 2 + 1) * (num768 * 2 + 1);
10259 if (!((double)num774 < (double)num777 * 0.8) && !GenVars.UndergroundDesertLocation.Intersects(new Rectangle(num763 - 8, num767 - 8, 16, 16)))
10260 {
10261 SonOfLakinater(num763, num767);
10262 GenVars.LakeX[GenVars.numLakes] = num763;
10263 GenVars.numLakes++;
10264 break;
10265 }
10266 }
10267 }
10268 }
10269 }
10270 }
10271 }
10272 }
10273 });
10274 AddGenerationPass("Dungeon", delegate(GenerationProgress progress, GameConfiguration passConfig)
10275 {
10276 progress.Set(1.0);
10277 int dungeonLocation = GenVars.dungeonLocation;
10278 int num755 = (int)((Main.worldSurface + Main.rockLayer) / 2.0) + genRand.Next(-200, 200);
10279 int num756 = (int)((Main.worldSurface + Main.rockLayer) / 2.0) + 200;
10280 int num757 = num755;
10281 bool flag47 = false;
10282 for (int num758 = 0; num758 < 10; num758++)
10283 {
10284 if (SolidTile(dungeonLocation, num757 + num758))
10285 {
10286 flag47 = true;
10287 break;
10288 }
10289 }
10290 if (!flag47)
10291 {
10292 for (; num757 < num756 && !SolidTile(dungeonLocation, num757 + 10); num757++)
10293 {
10294 }
10295 }
10296 if (drunkWorldGen)
10297 {
10298 num757 = (int)Main.worldSurface + 70;
10299 }
10300 MakeDungeon(dungeonLocation, num757);
10301 });
10302 AddGenerationPass("Slush", delegate
10303 {
10304 for (int num750 = GenVars.snowTop; num750 < GenVars.snowBottom; num750++)
10305 {
10306 for (int num751 = GenVars.snowMinX[num750]; num751 < GenVars.snowMaxX[num750]; num751++)
10307 {
10308 switch (Main.tile[num751, num750].type)
10309 {
10310 case 123:
10311 Main.tile[num751, num750].type = 224;
10312 break;
10313 case 59:
10314 {
10315 bool flag46 = true;
10316 int num752 = 3;
10317 for (int num753 = num751 - num752; num753 <= num751 + num752; num753++)
10318 {
10319 for (int num754 = num750 - num752; num754 <= num750 + num752; num754++)
10320 {
10321 if (Main.tile[num753, num754].type == 60 || Main.tile[num753, num754].type == 70 || Main.tile[num753, num754].type == 71 || Main.tile[num753, num754].type == 72)
10322 {
10323 flag46 = false;
10324 break;
10325 }
10326 }
10327 }
10328 if (flag46)
10329 {
10330 Main.tile[num751, num750].type = 224;
10331 }
10332 break;
10333 }
10334 case 1:
10335 Main.tile[num751, num750].type = 161;
10336 break;
10337 }
10338 }
10339 }
10340 });
10341 AddGenerationPass("Mountain Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
10342 {
10343 progress.Message = Lang.gen[21].Value;
10344 for (int num749 = 0; num749 < GenVars.numMCaves; num749++)
10345 {
10346 int i3 = GenVars.mCaveX[num749];
10347 int j5 = GenVars.mCaveY[num749];
10348 CaveOpenater(i3, j5);
10349 Cavinator(i3, j5, genRand.Next(40, 50));
10350 }
10351 });
10352 AddGenerationPass("Beaches", delegate(GenerationProgress progress, GameConfiguration passConfig)
10353 {
10354 int num731 = 50;
10355 progress.Message = Lang.gen[22].Value;
10356 bool floridaStyle = false;
10357 bool floridaStyle2 = false;
10358 if (genRand.Next(4) == 0)
10359 {
10360 if (genRand.Next(2) == 0)
10361 {
10362 floridaStyle = true;
10363 }
10364 else
10365 {
10366 floridaStyle2 = true;
10367 }
10368 }
10369 for (int num732 = 0; num732 < 2; num732++)
10370 {
10371 int num733 = 0;
10372 int num734 = 0;
10373 if (num732 == 0)
10374 {
10375 num733 = 0;
10376 num734 = genRand.Next(GenVars.oceanWaterStartRandomMin, GenVars.oceanWaterStartRandomMax);
10377 if (GenVars.dungeonSide == 1)
10378 {
10379 num734 = GenVars.oceanWaterForcedJungleLength;
10380 }
10381 int num735 = GenVars.leftBeachEnd - num731;
10382 if (num734 > num735)
10383 {
10384 num734 = num735;
10385 }
10386 int num736 = 0;
10387 double num737 = 1.0;
10388 int num738;
10389 for (num738 = 0; !Main.tile[num734 - 1, num738].active(); num738++)
10390 {
10391 }
10392 GenVars.shellStartYLeft = num738;
10393 num738 += genRand.Next(1, 5);
10394 for (int num739 = num734 - 1; num739 >= num733; num739--)
10395 {
10396 if (num739 > 30)
10397 {
10398 num736++;
10399 num737 = TuneOceanDepth(num736, num737, floridaStyle);
10400 }
10401 else
10402 {
10403 num737 += 1.0;
10404 }
10405 int num740 = genRand.Next(15, 20);
10406 for (int num741 = 0; (double)num741 < (double)num738 + num737 + (double)num740; num741++)
10407 {
10408 if ((double)num741 < (double)num738 + num737 * 0.75 - 3.0)
10409 {
10410 Main.tile[num739, num741].active(active: false);
10411 if (num741 > num738)
10412 {
10413 Main.tile[num739, num741].liquid = byte.MaxValue;
10414 Main.tile[num739, num741].lava(lava: false);
10415 }
10416 else if (num741 == num738)
10417 {
10418 Main.tile[num739, num741].liquid = 127;
10419 if (GenVars.shellStartXLeft == 0)
10420 {
10421 GenVars.shellStartXLeft = num739;
10422 }
10423 }
10424 }
10425 else if (num741 > num738)
10426 {
10427 Main.tile[num739, num741].type = 53;
10428 Main.tile[num739, num741].active(active: true);
10429 }
10430 Main.tile[num739, num741].wall = 0;
10431 }
10432 }
10433 }
10434 else
10435 {
10436 num733 = Main.maxTilesX - genRand.Next(GenVars.oceanWaterStartRandomMin, GenVars.oceanWaterStartRandomMax);
10437 num734 = Main.maxTilesX;
10438 if (GenVars.dungeonSide == -1)
10439 {
10440 num733 = Main.maxTilesX - GenVars.oceanWaterForcedJungleLength;
10441 }
10442 int num742 = GenVars.rightBeachStart + num731;
10443 if (num733 < num742)
10444 {
10445 num733 = num742;
10446 }
10447 double num743 = 1.0;
10448 int num744 = 0;
10449 int num745;
10450 for (num745 = 0; !Main.tile[num733, num745].active(); num745++)
10451 {
10452 }
10453 GenVars.shellStartXRight = 0;
10454 GenVars.shellStartYRight = num745;
10455 num745 += genRand.Next(1, 5);
10456 for (int num746 = num733; num746 < num734; num746++)
10457 {
10458 if (num746 < num734 - 30)
10459 {
10460 num744++;
10461 num743 = TuneOceanDepth(num744, num743, floridaStyle2);
10462 }
10463 else
10464 {
10465 num743 += 1.0;
10466 }
10467 int num747 = genRand.Next(15, 20);
10468 for (int num748 = 0; (double)num748 < (double)num745 + num743 + (double)num747; num748++)
10469 {
10470 if ((double)num748 < (double)num745 + num743 * 0.75 - 3.0)
10471 {
10472 Main.tile[num746, num748].active(active: false);
10473 if (num748 > num745)
10474 {
10475 Main.tile[num746, num748].liquid = byte.MaxValue;
10476 Main.tile[num746, num748].lava(lava: false);
10477 }
10478 else if (num748 == num745)
10479 {
10480 Main.tile[num746, num748].liquid = 127;
10481 if (GenVars.shellStartXRight == 0)
10482 {
10483 GenVars.shellStartXRight = num746;
10484 }
10485 }
10486 }
10487 else if (num748 > num745)
10488 {
10489 Main.tile[num746, num748].type = 53;
10490 Main.tile[num746, num748].active(active: true);
10491 }
10492 Main.tile[num746, num748].wall = 0;
10493 }
10494 }
10495 }
10496 }
10497 });
10498 AddGenerationPass("Gems", delegate(GenerationProgress progress, GameConfiguration passConfig)
10499 {
10500 progress.Message = Lang.gen[23].Value;
10501 Main.tileSolid[484] = false;
10502 for (int num718 = 63; num718 <= 68; num718++)
10503 {
10504 double value13 = (double)(num718 - 63) / 6.0;
10505 progress.Set(value13);
10506 double num719 = 0.0;
10507 switch (num718)
10508 {
10509 case 67:
10510 num719 = (double)Main.maxTilesX * 0.5;
10511 break;
10512 case 66:
10513 num719 = (double)Main.maxTilesX * 0.45;
10514 break;
10515 case 63:
10516 num719 = (double)Main.maxTilesX * 0.3;
10517 break;
10518 case 65:
10519 num719 = (double)Main.maxTilesX * 0.25;
10520 break;
10521 case 64:
10522 num719 = (double)Main.maxTilesX * 0.1;
10523 break;
10524 case 68:
10525 num719 = (double)Main.maxTilesX * 0.05;
10526 break;
10527 }
10528 num719 *= 0.2;
10529 for (int num720 = 0; (double)num720 < num719; num720++)
10530 {
10531 int num721 = genRand.Next(0, Main.maxTilesX);
10532 int num722 = genRand.Next((int)Main.worldSurface, Main.maxTilesY);
10533 while (Main.tile[num721, num722].type != 1)
10534 {
10535 num721 = genRand.Next(0, Main.maxTilesX);
10536 num722 = genRand.Next((int)Main.worldSurface, Main.maxTilesY);
10537 }
10538 TileRunner(num721, num722, genRand.Next(2, 6), genRand.Next(3, 7), num718);
10539 }
10540 }
10541 for (int num723 = 0; num723 < 2; num723++)
10542 {
10543 int num724 = 1;
10544 int num725 = 5;
10545 int num726 = Main.maxTilesX - 5;
10546 if (num723 == 1)
10547 {
10548 num724 = -1;
10549 num725 = Main.maxTilesX - 5;
10550 num726 = 5;
10551 }
10552 for (int num727 = num725; num727 != num726; num727 += num724)
10553 {
10554 if (num727 <= GenVars.UndergroundDesertLocation.Left || num727 >= GenVars.UndergroundDesertLocation.Right)
10555 {
10556 for (int num728 = 10; num728 < Main.maxTilesY - 10; num728++)
10557 {
10558 if (Main.tile[num727, num728].active() && Main.tile[num727, num728 + 1].active() && Main.tileSand[Main.tile[num727, num728].type] && Main.tileSand[Main.tile[num727, num728 + 1].type])
10559 {
10560 ushort type9 = Main.tile[num727, num728].type;
10561 int num729 = num727 + num724;
10562 int num730 = num728 + 1;
10563 if (!Main.tile[num729, num728].active() && !Main.tile[num729, num730].active())
10564 {
10565 for (; !Main.tile[num729, num730].active(); num730++)
10566 {
10567 }
10568 num730--;
10569 Main.tile[num727, num728].active(active: false);
10570 Main.tile[num729, num730].active(active: true);
10571 Main.tile[num729, num730].type = type9;
10572 }
10573 }
10574 }
10575 }
10576 }
10577 }
10578 });
10579 AddGenerationPass("Gravitating Sand", delegate(GenerationProgress progress, GameConfiguration passConfig)
10580 {
10581 progress.Message = Lang.gen[24].Value;
10582 for (int num714 = 0; num714 < Main.maxTilesX; num714++)
10583 {
10584 double value12 = (double)num714 / (double)(Main.maxTilesX - 1);
10585 progress.Set(value12);
10586 bool flag45 = false;
10587 int num715 = 0;
10588 for (int num716 = Main.maxTilesY - 1; num716 > 0; num716--)
10589 {
10590 if (SolidOrSlopedTile(num714, num716))
10591 {
10592 ushort type8 = Main.tile[num714, num716].type;
10593 if (flag45 && num716 < (int)Main.worldSurface && num716 != num715 - 1 && TileID.Sets.Falling[type8])
10594 {
10595 for (int num717 = num716; num717 < num715; num717++)
10596 {
10597 Main.tile[num714, num717].ResetToType(type8);
10598 }
10599 }
10600 flag45 = true;
10601 num715 = num716;
10602 }
10603 }
10604 }
10605 });
10606 AddGenerationPass("Create Ocean Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
10607 {
10608 int maxValue11 = 3;
10609 if (remixWorldGen)
10610 {
10611 maxValue11 = 2;
10612 }
10613 for (int num711 = 0; num711 < 2; num711++)
10614 {
10615 if ((num711 != 0 || GenVars.dungeonSide <= 0) && (num711 != 1 || GenVars.dungeonSide >= 0) && (genRand.Next(maxValue11) == 0 || drunkWorldGen || tenthAnniversaryWorldGen))
10616 {
10617 progress.Message = Lang.gen[90].Value;
10618 int num712 = genRand.Next(55, 95);
10619 if (num711 == 1)
10620 {
10621 num712 = genRand.Next(Main.maxTilesX - 95, Main.maxTilesX - 55);
10622 }
10623 int num713;
10624 for (num713 = 0; !Main.tile[num712, num713].active(); num713++)
10625 {
10626 }
10627 oceanCave(num712, num713);
10628 }
10629 }
10630 });
10631 AddGenerationPass("Shimmer", delegate
10632 {
10633 //IL_028b: Unknown result type (might be due to invalid IL or missing references)
10634 //IL_0290: Unknown result type (might be due to invalid IL or missing references)
10635 int num702 = 50;
10636 int num703 = (int)(Main.worldSurface + Main.rockLayer) / 2 + num702;
10637 int num704 = (int)((double)((Main.maxTilesY - 250) * 2) + Main.rockLayer) / 3;
10638 if (num704 > Main.maxTilesY - 330 - 100 - 30)
10639 {
10640 num704 = Main.maxTilesY - 330 - 100 - 30;
10641 }
10642 if (num704 <= num703)
10643 {
10644 num704 = num703 + 50;
10645 }
10646 int num705 = genRand.Next(num703, num704);
10647 int num706 = ((GenVars.dungeonSide < 0) ? genRand.Next((int)((double)Main.maxTilesX * 0.89), Main.maxTilesX - 200) : genRand.Next(200, (int)((double)Main.maxTilesX * 0.11)));
10648 int num707 = (int)Main.worldSurface + 150;
10649 int num708 = (int)(Main.rockLayer + Main.worldSurface + 200.0) / 2;
10650 if (num708 <= num707)
10651 {
10652 num708 = num707 + 50;
10653 }
10654 if (tenthAnniversaryWorldGen)
10655 {
10656 num705 = genRand.Next(num707, num708);
10657 }
10658 int num709 = 0;
10659 while (!ShimmerMakeBiome(num706, num705))
10660 {
10661 num709++;
10662 if (tenthAnniversaryWorldGen && num709 < 10000)
10663 {
10664 num705 = genRand.Next(num707, num708);
10665 num706 = ((GenVars.dungeonSide < 0) ? genRand.Next((int)((double)Main.maxTilesX * 0.89), Main.maxTilesX - 200) : genRand.Next(200, (int)((double)Main.maxTilesX * 0.11)));
10666 }
10667 else if (num709 > 20000)
10668 {
10669 num705 = genRand.Next((int)Main.worldSurface + 100 + 20, num704);
10670 num706 = ((GenVars.dungeonSide < 0) ? genRand.Next((int)((double)Main.maxTilesX * 0.8), Main.maxTilesX - 200) : genRand.Next(200, (int)((double)Main.maxTilesX * 0.2)));
10671 }
10672 else
10673 {
10674 num705 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2 + 20, num704);
10675 num706 = ((GenVars.dungeonSide < 0) ? genRand.Next((int)((double)Main.maxTilesX * 0.89), Main.maxTilesX - 200) : genRand.Next(200, (int)((double)Main.maxTilesX * 0.11)));
10676 }
10677 }
10678 GenVars.shimmerPosition = new Vector2D((double)num706, (double)num705);
10679 int num710 = 200;
10680 GenVars.structures.AddProtectedStructure(new Rectangle(num706 - num710 / 2, num705 - num710 / 2, num710, num710));
10681 });
10682 AddGenerationPass("Clean Up Dirt", delegate(GenerationProgress progress, GameConfiguration passConfig)
10683 {
10684 progress.Message = Lang.gen[25].Value;
10685 for (int num696 = 3; num696 < Main.maxTilesX - 3; num696++)
10686 {
10687 double num697 = (double)num696 / (double)Main.maxTilesX;
10688 progress.Set(0.5 * num697);
10689 bool flag43 = true;
10690 for (int num698 = 0; (double)num698 < Main.worldSurface; num698++)
10691 {
10692 if (flag43)
10693 {
10694 if (Main.tile[num696, num698].wall == 2 || Main.tile[num696, num698].wall == 40 || Main.tile[num696, num698].wall == 64 || Main.tile[num696, num698].wall == 86)
10695 {
10696 Main.tile[num696, num698].wall = 0;
10697 }
10698 if (Main.tile[num696, num698].type != 53 && Main.tile[num696, num698].type != 112 && Main.tile[num696, num698].type != 234)
10699 {
10700 if (Main.tile[num696 - 1, num698].wall == 2 || Main.tile[num696 - 1, num698].wall == 40 || Main.tile[num696 - 1, num698].wall == 40)
10701 {
10702 Main.tile[num696 - 1, num698].wall = 0;
10703 }
10704 if ((Main.tile[num696 - 2, num698].wall == 2 || Main.tile[num696 - 2, num698].wall == 40 || Main.tile[num696 - 2, num698].wall == 40) && genRand.Next(2) == 0)
10705 {
10706 Main.tile[num696 - 2, num698].wall = 0;
10707 }
10708 if ((Main.tile[num696 - 3, num698].wall == 2 || Main.tile[num696 - 3, num698].wall == 40 || Main.tile[num696 - 3, num698].wall == 40) && genRand.Next(2) == 0)
10709 {
10710 Main.tile[num696 - 3, num698].wall = 0;
10711 }
10712 if (Main.tile[num696 + 1, num698].wall == 2 || Main.tile[num696 + 1, num698].wall == 40 || Main.tile[num696 + 1, num698].wall == 40)
10713 {
10714 Main.tile[num696 + 1, num698].wall = 0;
10715 }
10716 if ((Main.tile[num696 + 2, num698].wall == 2 || Main.tile[num696 + 2, num698].wall == 40 || Main.tile[num696 + 2, num698].wall == 40) && genRand.Next(2) == 0)
10717 {
10718 Main.tile[num696 + 2, num698].wall = 0;
10719 }
10720 if ((Main.tile[num696 + 3, num698].wall == 2 || Main.tile[num696 + 3, num698].wall == 40 || Main.tile[num696 + 3, num698].wall == 40) && genRand.Next(2) == 0)
10721 {
10722 Main.tile[num696 + 3, num698].wall = 0;
10723 }
10724 if (Main.tile[num696, num698].active())
10725 {
10726 flag43 = false;
10727 }
10728 }
10729 }
10730 else if (Main.tile[num696, num698].wall == 0 && Main.tile[num696, num698 + 1].wall == 0 && Main.tile[num696, num698 + 2].wall == 0 && Main.tile[num696, num698 + 3].wall == 0 && Main.tile[num696, num698 + 4].wall == 0 && Main.tile[num696 - 1, num698].wall == 0 && Main.tile[num696 + 1, num698].wall == 0 && Main.tile[num696 - 2, num698].wall == 0 && Main.tile[num696 + 2, num698].wall == 0 && !Main.tile[num696, num698].active() && !Main.tile[num696, num698 + 1].active() && !Main.tile[num696, num698 + 2].active() && !Main.tile[num696, num698 + 3].active())
10731 {
10732 flag43 = true;
10733 }
10734 }
10735 }
10736 for (int num699 = Main.maxTilesX - 5; num699 >= 5; num699--)
10737 {
10738 double num700 = (double)num699 / (double)Main.maxTilesX;
10739 progress.Set(1.0 - 0.5 * num700);
10740 bool flag44 = true;
10741 for (int num701 = 0; (double)num701 < Main.worldSurface; num701++)
10742 {
10743 if (flag44)
10744 {
10745 if (Main.tile[num699, num701].wall == 2 || Main.tile[num699, num701].wall == 40 || Main.tile[num699, num701].wall == 64)
10746 {
10747 Main.tile[num699, num701].wall = 0;
10748 }
10749 if (Main.tile[num699, num701].type != 53)
10750 {
10751 if (Main.tile[num699 - 1, num701].wall == 2 || Main.tile[num699 - 1, num701].wall == 40 || Main.tile[num699 - 1, num701].wall == 40)
10752 {
10753 Main.tile[num699 - 1, num701].wall = 0;
10754 }
10755 if ((Main.tile[num699 - 2, num701].wall == 2 || Main.tile[num699 - 2, num701].wall == 40 || Main.tile[num699 - 2, num701].wall == 40) && genRand.Next(2) == 0)
10756 {
10757 Main.tile[num699 - 2, num701].wall = 0;
10758 }
10759 if ((Main.tile[num699 - 3, num701].wall == 2 || Main.tile[num699 - 3, num701].wall == 40 || Main.tile[num699 - 3, num701].wall == 40) && genRand.Next(2) == 0)
10760 {
10761 Main.tile[num699 - 3, num701].wall = 0;
10762 }
10763 if (Main.tile[num699 + 1, num701].wall == 2 || Main.tile[num699 + 1, num701].wall == 40 || Main.tile[num699 + 1, num701].wall == 40)
10764 {
10765 Main.tile[num699 + 1, num701].wall = 0;
10766 }
10767 if ((Main.tile[num699 + 2, num701].wall == 2 || Main.tile[num699 + 2, num701].wall == 40 || Main.tile[num699 + 2, num701].wall == 40) && genRand.Next(2) == 0)
10768 {
10769 Main.tile[num699 + 2, num701].wall = 0;
10770 }
10771 if ((Main.tile[num699 + 3, num701].wall == 2 || Main.tile[num699 + 3, num701].wall == 40 || Main.tile[num699 + 3, num701].wall == 40) && genRand.Next(2) == 0)
10772 {
10773 Main.tile[num699 + 3, num701].wall = 0;
10774 }
10775 if (Main.tile[num699, num701].active())
10776 {
10777 flag44 = false;
10778 }
10779 }
10780 }
10781 else if (Main.tile[num699, num701].wall == 0 && Main.tile[num699, num701 + 1].wall == 0 && Main.tile[num699, num701 + 2].wall == 0 && Main.tile[num699, num701 + 3].wall == 0 && Main.tile[num699, num701 + 4].wall == 0 && Main.tile[num699 - 1, num701].wall == 0 && Main.tile[num699 + 1, num701].wall == 0 && Main.tile[num699 - 2, num701].wall == 0 && Main.tile[num699 + 2, num701].wall == 0 && !Main.tile[num699, num701].active() && !Main.tile[num699, num701 + 1].active() && !Main.tile[num699, num701 + 2].active() && !Main.tile[num699, num701 + 3].active())
10782 {
10783 flag44 = true;
10784 }
10785 }
10786 }
10787 });
10788 AddGenerationPass("Pyramids", delegate
10789 {
10790 Rectangle undergroundDesertLocation = GenVars.UndergroundDesertLocation;
10791 if (Main.tenthAnniversaryWorld)
10792 {
10793 int x15 = undergroundDesertLocation.Center.X;
10794 int j4 = undergroundDesertLocation.Top - 10;
10795 Pyramid(x15, j4);
10796 }
10797 for (int num689 = 0; num689 < GenVars.numPyr; num689++)
10798 {
10799 int num690 = GenVars.PyrX[num689];
10800 int num691 = GenVars.PyrY[num689];
10801 if (num690 > 300 && num690 < Main.maxTilesX - 300 && (GenVars.dungeonSide >= 0 || !((double)num690 < (double)GenVars.dungeonX + (double)Main.maxTilesX * 0.15)) && (GenVars.dungeonSide <= 0 || !((double)num690 > (double)GenVars.dungeonX - (double)Main.maxTilesX * 0.15)) && (!Main.tenthAnniversaryWorld || !undergroundDesertLocation.Contains(num690, num691)))
10802 {
10803 for (; !Main.tile[num690, num691].active() && (double)num691 < Main.worldSurface; num691++)
10804 {
10805 }
10806 if (!((double)num691 >= Main.worldSurface) && Main.tile[num690, num691].type == 53)
10807 {
10808 int num692 = Main.maxTilesX;
10809 for (int num693 = 0; num693 < num689; num693++)
10810 {
10811 int num694 = Math.Abs(num690 - GenVars.PyrX[num693]);
10812 if (num694 < num692)
10813 {
10814 num692 = num694;
10815 }
10816 }
10817 int num695 = 220;
10818 if (drunkWorldGen)
10819 {
10820 num695 /= 2;
10821 }
10822 if (num692 >= num695)
10823 {
10824 num691--;
10825 Pyramid(num690, num691);
10826 }
10827 }
10828 }
10829 }
10830 });
10831 AddGenerationPass("Dirt Rock Wall Runner", delegate
10832 {
10833 for (int num686 = 0; num686 < Main.maxTilesX; num686++)
10834 {
10835 int num687 = genRand.Next(10, Main.maxTilesX - 10);
10836 int num688 = genRand.Next(10, (int)Main.worldSurface);
10837 if (Main.tile[num687, num688].wall == 2)
10838 {
10839 DirtyRockRunner(num687, num688);
10840 }
10841 }
10842 });
10843 AddGenerationPass("Living Trees", delegate
10844 {
10845 int num669 = 200;
10846 double num670 = (double)Main.maxTilesX / 4200.0;
10847 int num671 = genRand.Next(0, (int)(2.0 * num670) + 1);
10848 if (num671 == 0 && genRand.Next(2) == 0)
10849 {
10850 num671++;
10851 }
10852 if (drunkWorldGen)
10853 {
10854 num671 += (int)(2.0 * num670);
10855 }
10856 else if (Main.tenthAnniversaryWorld)
10857 {
10858 num671 += (int)(3.0 * num670);
10859 }
10860 else if (remixWorldGen)
10861 {
10862 num671 += (int)(2.0 * num670);
10863 }
10864 for (int num672 = 0; num672 < num671; num672++)
10865 {
10866 bool flag41 = false;
10867 int num673 = 0;
10868 while (!flag41)
10869 {
10870 num673++;
10871 if (num673 > Main.maxTilesX / 2)
10872 {
10873 flag41 = true;
10874 }
10875 int num674 = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
10876 if (tenthAnniversaryWorldGen && !remixWorldGen)
10877 {
10878 num674 = genRand.Next((int)((double)Main.maxTilesX * 0.15), (int)((float)Main.maxTilesX * 0.85f));
10879 }
10880 if (num674 <= Main.maxTilesX / 2 - num669 || num674 >= Main.maxTilesX / 2 + num669)
10881 {
10882 int num675;
10883 for (num675 = 0; !Main.tile[num674, num675].active() && (double)num675 < Main.worldSurface; num675++)
10884 {
10885 }
10886 if (Main.tile[num674, num675].type == 0)
10887 {
10888 num675--;
10889 if (num675 > 150)
10890 {
10891 bool flag42 = true;
10892 for (int num676 = num674 - 50; num676 < num674 + 50; num676++)
10893 {
10894 for (int num677 = num675 - 50; num677 < num675 + 50; num677++)
10895 {
10896 if (Main.tile[num676, num677].active())
10897 {
10898 switch (Main.tile[num676, num677].type)
10899 {
10900 case 41:
10901 case 43:
10902 case 44:
10903 case 189:
10904 case 196:
10905 case 460:
10906 case 481:
10907 case 482:
10908 case 483:
10909 flag42 = false;
10910 break;
10911 }
10912 }
10913 }
10914 }
10915 for (int num678 = 0; num678 < GenVars.numMCaves; num678++)
10916 {
10917 if (num674 > GenVars.mCaveX[num678] - 50 && num674 < GenVars.mCaveX[num678] + 50)
10918 {
10919 flag42 = false;
10920 break;
10921 }
10922 }
10923 if (flag42)
10924 {
10925 flag41 = GrowLivingTree(num674, num675);
10926 if (flag41)
10927 {
10928 for (int num679 = -1; num679 <= 1; num679++)
10929 {
10930 if (num679 != 0)
10931 {
10932 int num680 = num674;
10933 int num681 = genRand.Next(4);
10934 if (drunkWorldGen || Main.tenthAnniversaryWorld)
10935 {
10936 num681 += genRand.Next(2, 5);
10937 }
10938 else if (remixWorldGen)
10939 {
10940 num681 += genRand.Next(1, 6);
10941 }
10942 for (int num682 = 0; num682 < num681; num682++)
10943 {
10944 num680 += genRand.Next(13, 31) * num679;
10945 if (num680 <= Main.maxTilesX / 2 - num669 || num680 >= Main.maxTilesX / 2 + num669)
10946 {
10947 int num683 = num675;
10948 if (Main.tile[num680, num683].active())
10949 {
10950 while (Main.tile[num680, num683].active())
10951 {
10952 num683--;
10953 }
10954 }
10955 else
10956 {
10957 for (; !Main.tile[num680, num683].active(); num683++)
10958 {
10959 }
10960 num683--;
10961 }
10962 flag42 = true;
10963 for (int num684 = num674 - 50; num684 < num674 + 50; num684++)
10964 {
10965 for (int num685 = num675 - 50; num685 < num675 + 50; num685++)
10966 {
10967 if (Main.tile[num684, num685].active())
10968 {
10969 switch (Main.tile[num684, num685].type)
10970 {
10971 case 41:
10972 case 43:
10973 case 44:
10974 case 189:
10975 case 196:
10976 case 460:
10977 case 481:
10978 case 482:
10979 case 483:
10980 flag42 = false;
10981 break;
10982 }
10983 }
10984 }
10985 }
10986 if (flag42)
10987 {
10988 GrowLivingTree(num680, num683, patch: true);
10989 }
10990 }
10991 }
10992 }
10993 }
10994 }
10995 }
10996 }
10997 }
10998 }
10999 }
11000 }
11001 Main.tileSolid[192] = false;
11002 });
11003 AddGenerationPass("Wood Tree Walls", delegate
11004 {
11005 for (int num665 = 25; num665 < Main.maxTilesX - 25; num665++)
11006 {
11007 for (int num666 = 25; (double)num666 < Main.worldSurface; num666++)
11008 {
11009 if (Main.tile[num665, num666].type == 191 || Main.tile[num665, num666 - 1].type == 191 || Main.tile[num665 - 1, num666].type == 191 || Main.tile[num665 + 1, num666].type == 191 || Main.tile[num665, num666 + 1].type == 191)
11010 {
11011 bool flag40 = true;
11012 for (int num667 = num665 - 1; num667 <= num665 + 1; num667++)
11013 {
11014 for (int num668 = num666 - 1; num668 <= num666 + 1; num668++)
11015 {
11016 if (num667 != num665 && num668 != num666 && Main.tile[num667, num668].type != 191 && Main.tile[num667, num668].wall != 244)
11017 {
11018 flag40 = false;
11019 }
11020 }
11021 }
11022 if (flag40)
11023 {
11024 Main.tile[num665, num666].wall = 244;
11025 }
11026 }
11027 }
11028 }
11029 });
11030 AddGenerationPass("Altars", delegate(GenerationProgress progress, GameConfiguration passConfig)
11031 {
11032 //IL_01ff: Unknown result type (might be due to invalid IL or missing references)
11033 //IL_0204: Unknown result type (might be due to invalid IL or missing references)
11034 Main.tileSolid[484] = false;
11035 progress.Message = Lang.gen[26].Value;
11036 int num660 = (int)((double)(Main.maxTilesX * Main.maxTilesY) * 3.3E-06);
11037 if (remixWorldGen)
11038 {
11039 num660 *= 3;
11040 }
11041 for (int num661 = 0; num661 < num660; num661++)
11042 {
11043 progress.Set((double)num661 / (double)num660);
11044 for (int num662 = 0; num662 < 10000; num662++)
11045 {
11046 int num663 = genRand.Next(281, Main.maxTilesX - 3 - 280);
11047 while ((double)num663 > (double)Main.maxTilesX * 0.45 && (double)num663 < (double)Main.maxTilesX * 0.55)
11048 {
11049 num663 = genRand.Next(281, Main.maxTilesX - 3 - 280);
11050 }
11051 int num664 = genRand.Next((int)(Main.worldSurface * 2.0 + Main.rockLayer) / 3, (int)(Main.rockLayer + (double)((Main.maxTilesY - 350) * 2)) / 3);
11052 if (remixWorldGen)
11053 {
11054 num664 = genRand.Next(100, (int)((double)Main.maxTilesY * 0.9));
11055 }
11056 while (oceanDepths(num663, num664) || Vector2D.Distance(new Vector2D((double)num663, (double)num664), GenVars.shimmerPosition) < (double)shimmerSafetyDistance)
11057 {
11058 num663 = genRand.Next(281, Main.maxTilesX - 3 - 280);
11059 while ((double)num663 > (double)Main.maxTilesX * 0.45 && (double)num663 < (double)Main.maxTilesX * 0.55)
11060 {
11061 num663 = genRand.Next(281, Main.maxTilesX - 3 - 280);
11062 }
11063 num664 = genRand.Next((int)(Main.worldSurface * 2.0 + Main.rockLayer) / 3, (int)(Main.rockLayer + (double)((Main.maxTilesY - 350) * 2)) / 3);
11064 if (remixWorldGen)
11065 {
11066 num664 = genRand.Next(100, (int)((double)Main.maxTilesY * 0.9));
11067 }
11068 }
11069 int style2 = (crimson ? 1 : 0);
11070 if (drunkWorldGen)
11071 {
11072 style2 = (GenVars.crimsonLeft ? ((num663 < Main.maxTilesX / 2) ? 1 : 0) : ((num663 >= Main.maxTilesX / 2) ? 1 : 0));
11073 }
11074 if (!IsTileNearby(num663, num664, 26, 3))
11075 {
11076 Place3x2(num663, num664, 26, style2);
11077 }
11078 if (Main.tile[num663, num664].type == 26)
11079 {
11080 break;
11081 }
11082 }
11083 }
11084 });
11085 AddGenerationPass("Wet Jungle", delegate(GenerationProgress progress, GameConfiguration passConfig)
11086 {
11087 progress.Set(1.0);
11088 for (int num658 = 0; num658 < Main.maxTilesX; num658++)
11089 {
11090 for (int num659 = (int)GenVars.worldSurfaceLow; (double)num659 < Main.worldSurface - 1.0; num659++)
11091 {
11092 if (Main.tile[num658, num659].active())
11093 {
11094 if (Main.tile[num658, num659].type == 60)
11095 {
11096 Main.tile[num658, num659 - 1].liquid = byte.MaxValue;
11097 Main.tile[num658, num659 - 2].liquid = byte.MaxValue;
11098 }
11099 break;
11100 }
11101 }
11102 }
11103 });
11104 AddGenerationPass("Jungle Temple", delegate(GenerationProgress progress, GameConfiguration passConfig)
11105 {
11106 int num648 = 0;
11107 progress.Message = Lang.gen[70].Value;
11108 long num649 = 0L;
11109 double num650 = 0.25;
11110 bool flag38 = false;
11111 while (true)
11112 {
11113 int num651 = (int)Main.rockLayer;
11114 int num652 = Main.maxTilesY - 500;
11115 if (num651 > num652 - 1)
11116 {
11117 num651 = num652 - 1;
11118 }
11119 int num653 = genRand.Next(num651, num652);
11120 int num654 = (int)(((genRand.NextDouble() * num650 + 0.1) * (double)(-GenVars.dungeonSide) + 0.5) * (double)Main.maxTilesX);
11121 if (remixWorldGen)
11122 {
11123 if (notTheBees)
11124 {
11125 num654 = ((GenVars.dungeonSide <= 0) ? genRand.Next((int)((double)Main.maxTilesX * 0.6), (int)((double)Main.maxTilesX * 0.8)) : genRand.Next((int)((double)Main.maxTilesX * 0.2), (int)((double)Main.maxTilesX * 0.4)));
11126 }
11127 else
11128 {
11129 num654 = genRand.Next((int)((double)Main.maxTilesX * 0.2), (int)((double)Main.maxTilesX * 0.8));
11130 while ((double)num654 > (double)Main.maxTilesX * 0.4 && (double)num654 < (double)Main.maxTilesX * 0.6)
11131 {
11132 num654 = genRand.Next((int)((double)Main.maxTilesX * 0.2), (int)((double)Main.maxTilesX * 0.8));
11133 }
11134 }
11135 while (Main.tile[num654, num653].active() || Main.tile[num654, num653].wall > 0 || (double)num653 > Main.worldSurface - 5.0)
11136 {
11137 num653--;
11138 }
11139 num653++;
11140 if (Main.tile[num654, num653].active() && (Main.tile[num654, num653].type == 60 || Main.tile[num654, num653].type == 59))
11141 {
11142 int num655 = 10;
11143 bool flag39 = false;
11144 for (int num656 = num654 - num655; num656 <= num656 + num655; num656++)
11145 {
11146 for (int num657 = num653 - num655; num657 < num655; num657++)
11147 {
11148 if (Main.tile[num656, num657].type == 191 || Main.tileDungeon[Main.tile[num656, num657].type])
11149 {
11150 flag39 = true;
11151 }
11152 }
11153 }
11154 if (!flag39)
11155 {
11156 flag38 = true;
11157 num653 -= 10 + genRand.Next(10);
11158 makeTemple(num654, num653);
11159 break;
11160 }
11161 }
11162 }
11163 else if (Main.tile[num654, num653].active() && Main.tile[num654, num653].type == 60)
11164 {
11165 flag38 = true;
11166 makeTemple(num654, num653);
11167 break;
11168 }
11169 if (num649++ > 2000000)
11170 {
11171 if (num650 == 0.35)
11172 {
11173 num648++;
11174 if (num648 > 10)
11175 {
11176 break;
11177 }
11178 }
11179 num650 = Math.Min(0.35, num650 + 0.05);
11180 num649 = 0L;
11181 }
11182 }
11183 if (!flag38)
11184 {
11185 int x14 = Main.maxTilesX - GenVars.dungeonX;
11186 int y14 = (int)Main.rockLayer + 100;
11187 if (remixWorldGen)
11188 {
11189 x14 = ((!notTheBees) ? ((GenVars.dungeonSide > 0) ? ((int)((double)Main.maxTilesX * 0.4)) : ((int)((double)Main.maxTilesX * 0.6))) : ((GenVars.dungeonSide > 0) ? ((int)((double)Main.maxTilesX * 0.3)) : ((int)((double)Main.maxTilesX * 0.7))));
11190 }
11191 makeTemple(x14, y14);
11192 }
11193 });
11194 AddGenerationPass("Hives", delegate(GenerationProgress progress, GameConfiguration passConfig)
11195 {
11196 progress.Message = Lang.gen[71].Value;
11197 double num639 = (double)Main.maxTilesX / 4200.0;
11198 double num640 = 1 + genRand.Next((int)(5.0 * num639), (int)(8.0 * num639));
11199 if (drunkWorldGen)
11200 {
11201 num640 *= 0.667;
11202 }
11203 int num641 = 10000;
11204 HiveBiome hiveBiome = GenVars.configuration.CreateBiome<HiveBiome>();
11205 HoneyPatchBiome honeyPatchBiome = GenVars.configuration.CreateBiome<HoneyPatchBiome>();
11206 while (num640 > 0.0 && num641 > 0)
11207 {
11208 num641--;
11209 Point origin3 = RandomWorldPoint((int)(Main.worldSurface + Main.rockLayer) >> 1, 20, 300, 20);
11210 if (drunkWorldGen)
11211 {
11212 RandomWorldPoint((int)Main.worldSurface, 20, 300, 20);
11213 }
11214 if (hiveBiome.Place(origin3, GenVars.structures))
11215 {
11216 num640 -= 1.0;
11217 int num642 = genRand.Next(5);
11218 int num643 = 0;
11219 int num644 = 10000;
11220 while (num643 < num642 && num644 > 0)
11221 {
11222 double num645 = genRand.NextDouble() * 60.0 + 30.0;
11223 double num646 = genRand.NextDouble() * 6.2831854820251465;
11224 int num647 = (int)(Math.Cos(num646) * num645) + origin3.X;
11225 int y13 = (int)(Math.Sin(num646) * num645) + origin3.Y;
11226 num644--;
11227 if (num647 > 50 && num647 < Main.maxTilesX - 50 && honeyPatchBiome.Place(new Point(num647, y13), GenVars.structures))
11228 {
11229 num643++;
11230 }
11231 }
11232 }
11233 }
11234 });
11235 AddGenerationPass("Jungle Chests", delegate
11236 {
11237 int num613 = genRand.Next(40, Main.maxTilesX - 40);
11238 int num614 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, Main.maxTilesY - 400);
11239 double num615 = genRand.Next(7, 12);
11240 num615 *= (double)Main.maxTilesX / 4200.0;
11241 int num616 = 0;
11242 for (int num617 = 0; (double)num617 < num615; num617++)
11243 {
11244 bool flag36 = true;
11245 while (flag36)
11246 {
11247 num616++;
11248 num613 = genRand.Next(40, Main.maxTilesX / 2 - 40);
11249 if (GenVars.dungeonSide < 0)
11250 {
11251 num613 += Main.maxTilesX / 2;
11252 }
11253 num614 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, Main.maxTilesY - 400);
11254 int num618 = genRand.Next(2, 4);
11255 int num619 = genRand.Next(2, 4);
11256 Rectangle area = new Rectangle(num613 - num618 - 1, num614 - num619 - 1, num618 + 1, num619 + 1);
11257 if (Main.tile[num613, num614].type == 60)
11258 {
11259 int num620 = 30;
11260 flag36 = false;
11261 for (int num621 = num613 - num620; num621 < num613 + num620; num621 += 3)
11262 {
11263 for (int num622 = num614 - num620; num622 < num614 + num620; num622 += 3)
11264 {
11265 if (Main.tile[num621, num622].active() && (Main.tile[num621, num622].type == 225 || Main.tile[num621, num622].type == 229 || Main.tile[num621, num622].type == 226 || Main.tile[num621, num622].type == 119 || Main.tile[num621, num622].type == 120))
11266 {
11267 flag36 = true;
11268 }
11269 if (Main.tile[num621, num622].wall == 86 || Main.tile[num621, num622].wall == 87)
11270 {
11271 flag36 = true;
11272 }
11273 }
11274 }
11275 if (!GenVars.structures.CanPlace(area, 1))
11276 {
11277 flag36 = true;
11278 }
11279 }
11280 if (!flag36)
11281 {
11282 ushort wall2 = 0;
11283 if (GenVars.jungleHut == 119)
11284 {
11285 wall2 = 23;
11286 }
11287 else if (GenVars.jungleHut == 120)
11288 {
11289 wall2 = 24;
11290 }
11291 else if (GenVars.jungleHut == 158)
11292 {
11293 wall2 = 42;
11294 }
11295 else if (GenVars.jungleHut == 175)
11296 {
11297 wall2 = 45;
11298 }
11299 else if (GenVars.jungleHut == 45)
11300 {
11301 wall2 = 10;
11302 }
11303 for (int num623 = num613 - num618 - 1; num623 <= num613 + num618 + 1; num623++)
11304 {
11305 for (int num624 = num614 - num619 - 1; num624 <= num614 + num619 + 1; num624++)
11306 {
11307 Main.tile[num623, num624].active(active: true);
11308 Main.tile[num623, num624].type = GenVars.jungleHut;
11309 Main.tile[num623, num624].liquid = 0;
11310 Main.tile[num623, num624].lava(lava: false);
11311 }
11312 }
11313 for (int num625 = num613 - num618; num625 <= num613 + num618; num625++)
11314 {
11315 for (int num626 = num614 - num619; num626 <= num614 + num619; num626++)
11316 {
11317 Main.tile[num625, num626].active(active: false);
11318 Main.tile[num625, num626].wall = wall2;
11319 }
11320 }
11321 bool flag37 = false;
11322 int num627 = 0;
11323 while (!flag37 && num627 < 100)
11324 {
11325 num627++;
11326 int num628 = genRand.Next(num613 - num618, num613 + num618 + 1);
11327 int num629 = genRand.Next(num614 - num619, num614 + num619 - 2);
11328 PlaceTile(num628, num629, 4, mute: true, forced: false, -1, 3);
11329 if (Main.tile[num628, num629].type == 4)
11330 {
11331 flag37 = true;
11332 }
11333 }
11334 for (int num630 = num613 - num618 - 1; num630 <= num613 + num618 + 1; num630++)
11335 {
11336 for (int num631 = num614 + num619 - 2; num631 <= num614 + num619; num631++)
11337 {
11338 Main.tile[num630, num631].active(active: false);
11339 }
11340 }
11341 for (int num632 = num613 - num618 - 1; num632 <= num613 + num618 + 1; num632++)
11342 {
11343 for (int num633 = num614 + num619 - 2; num633 <= num614 + num619 - 1; num633++)
11344 {
11345 Main.tile[num632, num633].active(active: false);
11346 }
11347 }
11348 for (int num634 = num613 - num618 - 1; num634 <= num613 + num618 + 1; num634++)
11349 {
11350 int num635 = 4;
11351 int num636 = num614 + num619 + 2;
11352 while (!Main.tile[num634, num636].active() && num636 < Main.maxTilesY && num635 > 0)
11353 {
11354 Main.tile[num634, num636].active(active: true);
11355 Main.tile[num634, num636].type = 59;
11356 num636++;
11357 num635--;
11358 }
11359 }
11360 num618 -= genRand.Next(1, 3);
11361 int num637 = num614 - num619 - 2;
11362 while (num618 > -1)
11363 {
11364 for (int num638 = num613 - num618 - 1; num638 <= num613 + num618 + 1; num638++)
11365 {
11366 Main.tile[num638, num637].active(active: true);
11367 Main.tile[num638, num637].type = GenVars.jungleHut;
11368 }
11369 num618 -= genRand.Next(1, 3);
11370 num637--;
11371 }
11372 GenVars.JChestX[GenVars.numJChests] = num613;
11373 GenVars.JChestY[GenVars.numJChests] = num614;
11374 GenVars.structures.AddProtectedStructure(area);
11375 GenVars.numJChests++;
11376 num616 = 0;
11377 }
11378 else if (num616 > Main.maxTilesX * 10)
11379 {
11380 num617++;
11381 num616 = 0;
11382 break;
11383 }
11384 }
11385 }
11386 Main.tileSolid[137] = false;
11387 });
11388 AddGenerationPass("Settle Liquids", delegate(GenerationProgress progress, GameConfiguration passConfig)
11389 {
11390 progress.Message = Lang.gen[27].Value;
11391 if (notTheBees)
11392 {
11393 NotTheBees();
11394 }
11395 Liquid.worldGenTilesIgnoreWater(ignoreSolids: true);
11396 Liquid.QuickWater(3);
11397 WaterCheck();
11398 int num606 = 0;
11399 Liquid.quickSettle = true;
11400 int num607 = 10;
11401 while (num606 < num607)
11402 {
11403 int num608 = Liquid.numLiquid + LiquidBuffer.numLiquidBuffer;
11404 num606++;
11405 double num609 = 0.0;
11406 int num610 = num608 * 5;
11407 while (Liquid.numLiquid > 0)
11408 {
11409 num610--;
11410 if (num610 < 0)
11411 {
11412 break;
11413 }
11414 double num611 = (double)(num608 - (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer)) / (double)num608;
11415 if (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer > num608)
11416 {
11417 num608 = Liquid.numLiquid + LiquidBuffer.numLiquidBuffer;
11418 }
11419 if (num611 > num609)
11420 {
11421 num609 = num611;
11422 }
11423 else
11424 {
11425 num611 = num609;
11426 }
11427 if (num606 == 1)
11428 {
11429 progress.Set(num611 / 3.0 + 0.33);
11430 }
11431 int num612 = 10;
11432 if (num606 > num612)
11433 {
11434 num612 = num606;
11435 }
11436 Liquid.UpdateLiquid();
11437 }
11438 WaterCheck();
11439 progress.Set((double)num606 * 0.1 / 3.0 + 0.66);
11440 }
11441 Liquid.quickSettle = false;
11442 Liquid.worldGenTilesIgnoreWater(ignoreSolids: false);
11443 Main.tileSolid[484] = false;
11444 });
11445 AddGenerationPass("Remove Water From Sand", delegate(GenerationProgress progress, GameConfiguration passConfig)
11446 {
11447 progress.Set(1.0);
11448 for (int num603 = 400; num603 < Main.maxTilesX - 400; num603++)
11449 {
11450 for (int num604 = 100; (double)num604 < Main.worldSurface - 1.0; num604++)
11451 {
11452 if (Main.tile[num603, num604].active())
11453 {
11454 ushort type7 = Main.tile[num603, num604].type;
11455 if (type7 == 53 || type7 == 396 || type7 == 397 || type7 == 404 || type7 == 407 || type7 == 151)
11456 {
11457 int num605 = num604;
11458 while (num605 > 100)
11459 {
11460 num605--;
11461 if (Main.tile[num603, num605].active())
11462 {
11463 break;
11464 }
11465 Main.tile[num603, num605].liquid = 0;
11466 }
11467 }
11468 break;
11469 }
11470 }
11471 }
11472 Main.tileSolid[192] = true;
11473 });
11474 AddGenerationPass("Oasis", delegate(GenerationProgress progress, GameConfiguration passConfig)
11475 {
11476 if (!notTheBees)
11477 {
11478 progress.Set(1.0);
11479 int num599 = Main.maxTilesX / 2100;
11480 num599 += genRand.Next(2);
11481 for (int num600 = 0; num600 < num599; num600++)
11482 {
11483 int num601 = beachDistance + 300;
11484 int num602 = Main.maxTilesX * 2;
11485 while (num602 > 0)
11486 {
11487 num602--;
11488 int x13 = genRand.Next(num601, Main.maxTilesX - num601);
11489 int y12 = genRand.Next(100, (int)Main.worldSurface);
11490 if (PlaceOasis(x13, y12))
11491 {
11492 num602 = -1;
11493 }
11494 }
11495 }
11496 }
11497 });
11498 AddGenerationPass("Shell Piles", delegate(GenerationProgress progress, GameConfiguration passConfig)
11499 {
11500 if (dontStarveWorldGen)
11501 {
11502 int num587 = (int)(5.0 * ((double)Main.maxTilesX / 4200.0));
11503 int num588 = 0;
11504 int num589 = 100;
11505 int num590 = Main.maxTilesX / 2;
11506 int num591 = num590 - num589;
11507 int num592 = num590 + num589;
11508 for (int num593 = 0; num593 < 80; num593++)
11509 {
11510 int num594 = genRand.Next(100, Main.maxTilesX - 100);
11511 if (num594 >= num591 && num594 <= num592)
11512 {
11513 num594 = genRand.Next(100, Main.maxTilesX - 100);
11514 if (num594 >= num591 && num594 <= num592)
11515 {
11516 continue;
11517 }
11518 }
11519 int y11 = (int)Main.worldSurface / 2;
11520 if (MarblePileWithStatues(num594, y11))
11521 {
11522 num588++;
11523 if (num588 >= num587)
11524 {
11525 break;
11526 }
11527 }
11528 }
11529 }
11530 if (!notTheBees)
11531 {
11532 progress.Set(1.0);
11533 if (genRand.Next(2) == 0)
11534 {
11535 int shellStartXLeft = GenVars.shellStartXLeft;
11536 int shellStartYLeft = GenVars.shellStartYLeft;
11537 for (int num595 = shellStartXLeft - 20; num595 <= shellStartXLeft + 20; num595++)
11538 {
11539 for (int num596 = shellStartYLeft - 10; num596 <= shellStartYLeft + 10; num596++)
11540 {
11541 if (Main.tile[num595, num596].active() && Main.tile[num595, num596].type == 53 && !Main.tile[num595, num596 - 1].active() && Main.tile[num595, num596 - 1].liquid == 0 && !Main.tile[num595 - 1, num596].active() && Main.tile[num595 - 1, num596].liquid > 0)
11542 {
11543 GenVars.shellStartXLeft = num595;
11544 GenVars.shellStartYLeft = num596;
11545 }
11546 }
11547 }
11548 GenVars.shellStartYLeft -= 50;
11549 GenVars.shellStartXLeft -= genRand.Next(5);
11550 if (genRand.Next(2) == 0)
11551 {
11552 GenVars.shellStartXLeft -= genRand.Next(10);
11553 }
11554 if (genRand.Next(3) == 0)
11555 {
11556 GenVars.shellStartXLeft -= genRand.Next(15);
11557 }
11558 if (genRand.Next(4) != 0)
11559 {
11560 ShellPile(GenVars.shellStartXLeft, GenVars.shellStartYLeft);
11561 }
11562 int maxValue9 = genRand.Next(2, 4);
11563 if (genRand.Next(maxValue9) == 0)
11564 {
11565 ShellPile(GenVars.shellStartXLeft - genRand.Next(10, 35), GenVars.shellStartYLeft);
11566 }
11567 if (genRand.Next(maxValue9) == 0)
11568 {
11569 ShellPile(GenVars.shellStartXLeft - genRand.Next(40, 65), GenVars.shellStartYLeft);
11570 }
11571 if (genRand.Next(maxValue9) == 0)
11572 {
11573 ShellPile(GenVars.shellStartXLeft - genRand.Next(70, 95), GenVars.shellStartYLeft);
11574 }
11575 if (genRand.Next(maxValue9) == 0)
11576 {
11577 ShellPile(GenVars.shellStartXLeft - genRand.Next(100, 125), GenVars.shellStartYLeft);
11578 }
11579 if (genRand.Next(maxValue9) == 0)
11580 {
11581 ShellPile(GenVars.shellStartXLeft + genRand.Next(10, 25), GenVars.shellStartYLeft);
11582 }
11583 }
11584 if (genRand.Next(2) == 0)
11585 {
11586 int shellStartXRight = GenVars.shellStartXRight;
11587 int shellStartYRight = GenVars.shellStartYRight;
11588 for (int num597 = shellStartXRight - 20; num597 <= shellStartXRight + 20; num597++)
11589 {
11590 for (int num598 = shellStartYRight - 10; num598 <= shellStartYRight + 10; num598++)
11591 {
11592 if (Main.tile[num597, num598].active() && Main.tile[num597, num598].type == 53 && !Main.tile[num597, num598 - 1].active() && Main.tile[num597, num598 - 1].liquid == 0 && !Main.tile[num597 + 1, num598].active() && Main.tile[num597 + 1, num598].liquid > 0)
11593 {
11594 GenVars.shellStartXRight = num597;
11595 GenVars.shellStartYRight = num598;
11596 }
11597 }
11598 }
11599 GenVars.shellStartYRight -= 50;
11600 GenVars.shellStartXRight += genRand.Next(5);
11601 if (genRand.Next(2) == 0)
11602 {
11603 GenVars.shellStartXLeft += genRand.Next(10);
11604 }
11605 if (genRand.Next(3) == 0)
11606 {
11607 GenVars.shellStartXLeft += genRand.Next(15);
11608 }
11609 if (genRand.Next(4) != 0)
11610 {
11611 ShellPile(GenVars.shellStartXRight, GenVars.shellStartYRight);
11612 }
11613 int maxValue10 = genRand.Next(2, 4);
11614 if (genRand.Next(maxValue10) == 0)
11615 {
11616 ShellPile(GenVars.shellStartXRight + genRand.Next(10, 35), GenVars.shellStartYRight);
11617 }
11618 if (genRand.Next(maxValue10) == 0)
11619 {
11620 ShellPile(GenVars.shellStartXRight + genRand.Next(40, 65), GenVars.shellStartYRight);
11621 }
11622 if (genRand.Next(maxValue10) == 0)
11623 {
11624 ShellPile(GenVars.shellStartXRight + genRand.Next(70, 95), GenVars.shellStartYRight);
11625 }
11626 if (genRand.Next(maxValue10) == 0)
11627 {
11628 ShellPile(GenVars.shellStartXRight + genRand.Next(100, 125), GenVars.shellStartYRight);
11629 }
11630 if (genRand.Next(maxValue10) == 0)
11631 {
11632 ShellPile(GenVars.shellStartXRight - genRand.Next(10, 25), GenVars.shellStartYRight);
11633 }
11634 }
11635 }
11636 });
11637 AddGenerationPass("Smooth World", delegate(GenerationProgress progress, GameConfiguration passConfig)
11638 {
11639 progress.Message = Lang.gen[60].Value;
11640 Main.tileSolid[GenVars.crackedType] = true;
11641 for (int num583 = 20; num583 < Main.maxTilesX - 20; num583++)
11642 {
11643 double value11 = (double)num583 / (double)Main.maxTilesX;
11644 progress.Set(value11);
11645 for (int num584 = 20; num584 < Main.maxTilesY - 20; num584++)
11646 {
11647 if (Main.tile[num583, num584].type != 48 && Main.tile[num583, num584].type != 137 && Main.tile[num583, num584].type != 232 && Main.tile[num583, num584].type != 191 && Main.tile[num583, num584].type != 151 && Main.tile[num583, num584].type != 274)
11648 {
11649 if (!Main.tile[num583, num584 - 1].active() && Main.tile[num583 - 1, num584].type != 136 && Main.tile[num583 + 1, num584].type != 136)
11650 {
11651 if (SolidTile(num583, num584) && TileID.Sets.CanBeClearedDuringGeneration[Main.tile[num583, num584].type])
11652 {
11653 if (!Main.tile[num583 - 1, num584].halfBrick() && !Main.tile[num583 + 1, num584].halfBrick() && Main.tile[num583 - 1, num584].slope() == 0 && Main.tile[num583 + 1, num584].slope() == 0)
11654 {
11655 if (SolidTile(num583, num584 + 1))
11656 {
11657 if (!SolidTile(num583 - 1, num584) && !Main.tile[num583 - 1, num584 + 1].halfBrick() && SolidTile(num583 - 1, num584 + 1) && SolidTile(num583 + 1, num584) && !Main.tile[num583 + 1, num584 - 1].active())
11658 {
11659 if (genRand.Next(2) == 0)
11660 {
11661 SlopeTile(num583, num584, 2);
11662 }
11663 else
11664 {
11665 PoundTile(num583, num584);
11666 }
11667 }
11668 else if (!SolidTile(num583 + 1, num584) && !Main.tile[num583 + 1, num584 + 1].halfBrick() && SolidTile(num583 + 1, num584 + 1) && SolidTile(num583 - 1, num584) && !Main.tile[num583 - 1, num584 - 1].active())
11669 {
11670 if (genRand.Next(2) == 0)
11671 {
11672 SlopeTile(num583, num584, 1);
11673 }
11674 else
11675 {
11676 PoundTile(num583, num584);
11677 }
11678 }
11679 else if (SolidTile(num583 + 1, num584 + 1) && SolidTile(num583 - 1, num584 + 1) && !Main.tile[num583 + 1, num584].active() && !Main.tile[num583 - 1, num584].active())
11680 {
11681 PoundTile(num583, num584);
11682 }
11683 if (SolidTile(num583, num584))
11684 {
11685 if (SolidTile(num583 - 1, num584) && SolidTile(num583 + 1, num584 + 2) && !Main.tile[num583 + 1, num584].active() && !Main.tile[num583 + 1, num584 + 1].active() && !Main.tile[num583 - 1, num584 - 1].active())
11686 {
11687 KillTile(num583, num584);
11688 }
11689 else if (SolidTile(num583 + 1, num584) && SolidTile(num583 - 1, num584 + 2) && !Main.tile[num583 - 1, num584].active() && !Main.tile[num583 - 1, num584 + 1].active() && !Main.tile[num583 + 1, num584 - 1].active())
11690 {
11691 KillTile(num583, num584);
11692 }
11693 else if (!Main.tile[num583 - 1, num584 + 1].active() && !Main.tile[num583 - 1, num584].active() && SolidTile(num583 + 1, num584) && SolidTile(num583, num584 + 2))
11694 {
11695 if (genRand.Next(5) == 0)
11696 {
11697 KillTile(num583, num584);
11698 }
11699 else if (genRand.Next(5) == 0)
11700 {
11701 PoundTile(num583, num584);
11702 }
11703 else
11704 {
11705 SlopeTile(num583, num584, 2);
11706 }
11707 }
11708 else if (!Main.tile[num583 + 1, num584 + 1].active() && !Main.tile[num583 + 1, num584].active() && SolidTile(num583 - 1, num584) && SolidTile(num583, num584 + 2))
11709 {
11710 if (genRand.Next(5) == 0)
11711 {
11712 KillTile(num583, num584);
11713 }
11714 else if (genRand.Next(5) == 0)
11715 {
11716 PoundTile(num583, num584);
11717 }
11718 else
11719 {
11720 SlopeTile(num583, num584, 1);
11721 }
11722 }
11723 }
11724 }
11725 if (SolidTile(num583, num584) && !Main.tile[num583 - 1, num584].active() && !Main.tile[num583 + 1, num584].active())
11726 {
11727 KillTile(num583, num584);
11728 }
11729 }
11730 }
11731 else if (!Main.tile[num583, num584].active() && Main.tile[num583, num584 + 1].type != 151 && Main.tile[num583, num584 + 1].type != 274)
11732 {
11733 if (Main.tile[num583 + 1, num584].type != 190 && Main.tile[num583 + 1, num584].type != 48 && Main.tile[num583 + 1, num584].type != 232 && SolidTile(num583 - 1, num584 + 1) && SolidTile(num583 + 1, num584) && !Main.tile[num583 - 1, num584].active() && !Main.tile[num583 + 1, num584 - 1].active())
11734 {
11735 if (Main.tile[num583 + 1, num584].type == 495)
11736 {
11737 PlaceTile(num583, num584, Main.tile[num583 + 1, num584].type);
11738 }
11739 else
11740 {
11741 PlaceTile(num583, num584, Main.tile[num583, num584 + 1].type);
11742 }
11743 if (genRand.Next(2) == 0)
11744 {
11745 SlopeTile(num583, num584, 2);
11746 }
11747 else
11748 {
11749 PoundTile(num583, num584);
11750 }
11751 }
11752 if (Main.tile[num583 - 1, num584].type != 190 && Main.tile[num583 - 1, num584].type != 48 && Main.tile[num583 - 1, num584].type != 232 && SolidTile(num583 + 1, num584 + 1) && SolidTile(num583 - 1, num584) && !Main.tile[num583 + 1, num584].active() && !Main.tile[num583 - 1, num584 - 1].active())
11753 {
11754 if (Main.tile[num583 - 1, num584].type == 495)
11755 {
11756 PlaceTile(num583, num584, Main.tile[num583 - 1, num584].type);
11757 }
11758 else
11759 {
11760 PlaceTile(num583, num584, Main.tile[num583, num584 + 1].type);
11761 }
11762 if (genRand.Next(2) == 0)
11763 {
11764 SlopeTile(num583, num584, 1);
11765 }
11766 else
11767 {
11768 PoundTile(num583, num584);
11769 }
11770 }
11771 }
11772 }
11773 else if (!Main.tile[num583, num584 + 1].active() && genRand.Next(2) == 0 && SolidTile(num583, num584) && !Main.tile[num583 - 1, num584].halfBrick() && !Main.tile[num583 + 1, num584].halfBrick() && Main.tile[num583 - 1, num584].slope() == 0 && Main.tile[num583 + 1, num584].slope() == 0 && SolidTile(num583, num584 - 1))
11774 {
11775 if (SolidTile(num583 - 1, num584) && !SolidTile(num583 + 1, num584) && SolidTile(num583 - 1, num584 - 1))
11776 {
11777 SlopeTile(num583, num584, 3);
11778 }
11779 else if (SolidTile(num583 + 1, num584) && !SolidTile(num583 - 1, num584) && SolidTile(num583 + 1, num584 - 1))
11780 {
11781 SlopeTile(num583, num584, 4);
11782 }
11783 }
11784 if (TileID.Sets.Conversion.Sand[Main.tile[num583, num584].type])
11785 {
11786 Tile.SmoothSlope(num583, num584, applyToNeighbors: false);
11787 }
11788 }
11789 }
11790 }
11791 for (int num585 = 20; num585 < Main.maxTilesX - 20; num585++)
11792 {
11793 for (int num586 = 20; num586 < Main.maxTilesY - 20; num586++)
11794 {
11795 if (genRand.Next(2) == 0 && !Main.tile[num585, num586 - 1].active() && Main.tile[num585, num586].type != 137 && Main.tile[num585, num586].type != 48 && Main.tile[num585, num586].type != 232 && Main.tile[num585, num586].type != 191 && Main.tile[num585, num586].type != 151 && Main.tile[num585, num586].type != 274 && Main.tile[num585, num586].type != 75 && Main.tile[num585, num586].type != 76 && SolidTile(num585, num586) && Main.tile[num585 - 1, num586].type != 137 && Main.tile[num585 + 1, num586].type != 137)
11796 {
11797 if (SolidTile(num585, num586 + 1) && SolidTile(num585 + 1, num586) && !Main.tile[num585 - 1, num586].active())
11798 {
11799 SlopeTile(num585, num586, 2);
11800 }
11801 if (SolidTile(num585, num586 + 1) && SolidTile(num585 - 1, num586) && !Main.tile[num585 + 1, num586].active())
11802 {
11803 SlopeTile(num585, num586, 1);
11804 }
11805 }
11806 if (Main.tile[num585, num586].slope() == 1 && !SolidTile(num585 - 1, num586))
11807 {
11808 SlopeTile(num585, num586);
11809 PoundTile(num585, num586);
11810 }
11811 if (Main.tile[num585, num586].slope() == 2 && !SolidTile(num585 + 1, num586))
11812 {
11813 SlopeTile(num585, num586);
11814 PoundTile(num585, num586);
11815 }
11816 }
11817 }
11818 Main.tileSolid[137] = true;
11819 Main.tileSolid[190] = false;
11820 Main.tileSolid[192] = false;
11821 Main.tileSolid[GenVars.crackedType] = false;
11822 });
11823 AddGenerationPass("Waterfalls", delegate(GenerationProgress progress, GameConfiguration passConfig)
11824 {
11825 progress.Message = Lang.gen[69].Value;
11826 Main.tileSolid[191] = false;
11827 for (int num574 = 20; num574 < Main.maxTilesX - 20; num574++)
11828 {
11829 double num575 = (double)num574 / (double)Main.maxTilesX;
11830 progress.Set(num575 * 0.5);
11831 for (int num576 = 20; num576 < Main.maxTilesY - 20; num576++)
11832 {
11833 if (SolidTile(num574, num576) && !Main.tile[num574 - 1, num576].active() && SolidTile(num574, num576 + 1) && !Main.tile[num574 + 1, num576].active() && (Main.tile[num574 - 1, num576].liquid > 0 || Main.tile[num574 + 1, num576].liquid > 0))
11834 {
11835 bool flag35 = true;
11836 int num577 = genRand.Next(8, 20);
11837 int num578 = genRand.Next(8, 20);
11838 num577 = num576 - num577;
11839 num578 += num576;
11840 for (int num579 = num577; num579 <= num578; num579++)
11841 {
11842 if (Main.tile[num574, num579].halfBrick())
11843 {
11844 flag35 = false;
11845 }
11846 }
11847 if ((Main.tile[num574, num576].type == 75 || Main.tile[num574, num576].type == 76) && genRand.Next(10) != 0)
11848 {
11849 flag35 = false;
11850 }
11851 if (flag35)
11852 {
11853 PoundTile(num574, num576);
11854 }
11855 }
11856 }
11857 }
11858 for (int num580 = 20; num580 < Main.maxTilesX - 20; num580++)
11859 {
11860 double num581 = (double)num580 / (double)Main.maxTilesX;
11861 progress.Set(num581 * 0.5 + 0.5);
11862 for (int num582 = 20; num582 < Main.maxTilesY - 20; num582++)
11863 {
11864 if (Main.tile[num580, num582].type != 48 && Main.tile[num580, num582].type != 232 && SolidTile(num580, num582) && SolidTile(num580, num582 + 1))
11865 {
11866 if (!SolidTile(num580 + 1, num582) && Main.tile[num580 - 1, num582].halfBrick() && Main.tile[num580 - 2, num582].liquid > 0)
11867 {
11868 PoundTile(num580, num582);
11869 }
11870 if (!SolidTile(num580 - 1, num582) && Main.tile[num580 + 1, num582].halfBrick() && Main.tile[num580 + 2, num582].liquid > 0)
11871 {
11872 PoundTile(num580, num582);
11873 }
11874 }
11875 }
11876 }
11877 Main.tileSolid[191] = true;
11878 });
11879 AddGenerationPass("Ice", delegate(GenerationProgress progress, GameConfiguration passConfig)
11880 {
11881 if (notTheBees)
11882 {
11883 NotTheBees();
11884 }
11885 progress.Set(1.0);
11886 for (int num572 = 10; num572 < Main.maxTilesX - 10; num572++)
11887 {
11888 for (int num573 = (int)Main.worldSurface; num573 < Main.maxTilesY - 100; num573++)
11889 {
11890 if (Main.tile[num572, num573].liquid > 0 && (!Main.tile[num572, num573].lava() || remixWorldGen))
11891 {
11892 MakeWateryIceThing(num572, num573);
11893 }
11894 }
11895 }
11896 Main.tileSolid[226] = false;
11897 Main.tileSolid[162] = false;
11898 });
11899 AddGenerationPass("Wall Variety", delegate(GenerationProgress progress, GameConfiguration passConfig)
11900 {
11901 //IL_0093: Unknown result type (might be due to invalid IL or missing references)
11902 //IL_0098: Unknown result type (might be due to invalid IL or missing references)
11903 progress.Message = Lang.gen[79].Value;
11904 double num568 = (double)(Main.maxTilesX * Main.maxTilesY) / 5040000.0;
11905 int num569 = (int)(300.0 * num568);
11906 int num570 = num569;
11907 ShapeData shapeData = new ShapeData();
11908 while (num569 > 0)
11909 {
11910 progress.Set(1.0 - (double)num569 / (double)num570);
11911 Point point2 = RandomWorldPoint((int)GenVars.worldSurface, 2, 190, 2);
11912 while (Vector2D.Distance(new Vector2D((double)point2.X, (double)point2.Y), GenVars.shimmerPosition) < (double)shimmerSafetyDistance)
11913 {
11914 point2 = RandomWorldPoint((int)GenVars.worldSurface, 2, 190, 2);
11915 }
11916 Tile tile6 = Main.tile[point2.X, point2.Y];
11917 Tile tile7 = Main.tile[point2.X, point2.Y - 1];
11918 ushort num571 = 0;
11919 if (tile6.type == 60)
11920 {
11921 num571 = (ushort)(204 + genRand.Next(4));
11922 }
11923 else if (tile6.type == 1 && tile7.wall == 0)
11924 {
11925 num571 = (remixWorldGen ? (((double)point2.Y > GenVars.rockLayer) ? ((ushort)(196 + genRand.Next(4))) : ((point2.Y <= GenVars.lavaLine || genRand.Next(2) != 0) ? ((ushort)(212 + genRand.Next(4))) : ((ushort)(208 + genRand.Next(4))))) : (((double)point2.Y < GenVars.rockLayer) ? ((ushort)(196 + genRand.Next(4))) : ((point2.Y >= GenVars.lavaLine) ? ((ushort)(208 + genRand.Next(4))) : ((ushort)(212 + genRand.Next(4))))));
11926 }
11927 if (tile6.active() && num571 != 0 && !tile7.active())
11928 {
11929 bool foundInvalidTile = false;
11930 bool flag34 = ((tile6.type != 60) ? WorldUtils.Gen(new Point(point2.X, point2.Y - 1), new ShapeFloodFill(1000), Actions.Chain(new Modifiers.IsNotSolid(), new Actions.Blank().Output(shapeData), new Actions.ContinueWrapper(Actions.Chain(new Modifiers.IsTouching(true, 60, 147, 161, 396, 397, 70, 191), new Modifiers.IsTouching(true, 147, 161, 396, 397, 70, 191), new Actions.Custom(delegate
11931 {
11932 foundInvalidTile = true;
11933 return true;
11934 }))))) : WorldUtils.Gen(new Point(point2.X, point2.Y - 1), new ShapeFloodFill(1000), Actions.Chain(new Modifiers.IsNotSolid(), new Actions.Blank().Output(shapeData), new Actions.ContinueWrapper(Actions.Chain(new Modifiers.IsTouching(true, 147, 161, 396, 397, 70, 191), new Actions.Custom(delegate
11935 {
11936 foundInvalidTile = true;
11937 return true;
11938 }))))));
11939 if (shapeData.Count > 50 && flag34 && !foundInvalidTile)
11940 {
11941 WorldUtils.Gen(new Point(point2.X, point2.Y), new ModShapes.OuterOutline(shapeData, useDiagonals: true, useInterior: true), Actions.Chain(new Modifiers.SkipWalls(87), new Actions.PlaceWall(num571)));
11942 num569--;
11943 }
11944 shapeData.Clear();
11945 }
11946 }
11947 });
11948 AddGenerationPass("Life Crystals", delegate(GenerationProgress progress, GameConfiguration passConfig)
11949 {
11950 if (getGoodWorldGen)
11951 {
11952 Main.tileSolid[56] = false;
11953 }
11954 if (notTheBees)
11955 {
11956 NotTheBees();
11957 }
11958 progress.Message = Lang.gen[28].Value;
11959 double num565 = (double)(Main.maxTilesX * Main.maxTilesY) * 2E-05;
11960 if (tenthAnniversaryWorldGen)
11961 {
11962 num565 *= 1.2;
11963 }
11964 if (Main.starGame)
11965 {
11966 num565 *= Main.starGameMath(0.2);
11967 }
11968 for (int num566 = 0; num566 < (int)num565; num566++)
11969 {
11970 double value10 = (double)num566 / ((double)(Main.maxTilesX * Main.maxTilesY) * 2E-05);
11971 progress.Set(value10);
11972 bool flag33 = false;
11973 int num567 = 0;
11974 while (!flag33)
11975 {
11976 int j3 = genRand.Next((int)(Main.worldSurface * 2.0 + Main.rockLayer) / 3, Main.maxTilesY - 300);
11977 if (remixWorldGen)
11978 {
11979 j3 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 400);
11980 }
11981 if (AddLifeCrystal(genRand.Next(Main.offLimitBorderTiles, Main.maxTilesX - Main.offLimitBorderTiles), j3))
11982 {
11983 flag33 = true;
11984 }
11985 else
11986 {
11987 num567++;
11988 if (num567 >= 10000)
11989 {
11990 flag33 = true;
11991 }
11992 }
11993 }
11994 }
11995 Main.tileSolid[225] = false;
11996 });
11997 AddGenerationPass("Statues", delegate(GenerationProgress progress, GameConfiguration passConfig)
11998 {
11999 progress.Message = Lang.gen[29].Value;
12000 int num558 = 0;
12001 double num559 = (double)Main.maxTilesX / 4200.0;
12002 int num560 = (int)((double)(GenVars.statueList.Length * 2) * num559);
12003 if (noTrapsWorldGen)
12004 {
12005 num560 *= 15;
12006 if (tenthAnniversaryWorldGen || notTheBees)
12007 {
12008 num560 /= 5;
12009 }
12010 }
12011 if (Main.starGame)
12012 {
12013 num560 = (int)((double)num560 * Main.starGameMath(0.2));
12014 }
12015 for (int num561 = 0; num561 < num560; num561++)
12016 {
12017 if (num558 >= GenVars.statueList.Length)
12018 {
12019 num558 = 0;
12020 }
12021 int x12 = GenVars.statueList[num558].X;
12022 int y10 = GenVars.statueList[num558].Y;
12023 double value9 = num561 / num560;
12024 progress.Set(value9);
12025 bool flag32 = false;
12026 int num562 = 0;
12027 while (!flag32)
12028 {
12029 int num563 = genRand.Next(20, Main.maxTilesX - 20);
12030 int num564 = genRand.Next((int)(Main.worldSurface * 2.0 + Main.rockLayer) / 3, Main.maxTilesY - 300);
12031 if (remixWorldGen)
12032 {
12033 genRand.Next((int)Main.worldSurface, Main.maxTilesY - 400);
12034 }
12035 while (oceanDepths(num563, num564))
12036 {
12037 num563 = genRand.Next(20, Main.maxTilesX - 20);
12038 num564 = genRand.Next((int)(Main.worldSurface * 2.0 + Main.rockLayer) / 3, Main.maxTilesY - 300);
12039 if (remixWorldGen)
12040 {
12041 genRand.Next((int)Main.worldSurface, Main.maxTilesY - 400);
12042 }
12043 }
12044 while (!Main.tile[num563, num564].active())
12045 {
12046 num564++;
12047 if (num564 >= Main.maxTilesY)
12048 {
12049 break;
12050 }
12051 }
12052 if (num564 < Main.maxTilesY)
12053 {
12054 num564--;
12055 if (!Main.tile[num563, num564].shimmer())
12056 {
12057 PlaceTile(num563, num564, x12, mute: true, forced: true, -1, y10);
12058 }
12059 if (Main.tile[num563, num564].active() && Main.tile[num563, num564].type == x12)
12060 {
12061 flag32 = true;
12062 if (GenVars.StatuesWithTraps.Contains(num558))
12063 {
12064 PlaceStatueTrap(num563, num564);
12065 }
12066 num558++;
12067 }
12068 else
12069 {
12070 num562++;
12071 if (num562 >= 10000)
12072 {
12073 flag32 = true;
12074 }
12075 }
12076 }
12077 }
12078 }
12079 });
12080 AddGenerationPass("Buried Chests", delegate(GenerationProgress progress, GameConfiguration passConfig)
12081 {
12082 progress.Message = Lang.gen[30].Value;
12083 Main.tileSolid[226] = true;
12084 Main.tileSolid[162] = true;
12085 Main.tileSolid[225] = true;
12086 CaveHouseBiome caveHouseBiome = GenVars.configuration.CreateBiome<CaveHouseBiome>();
12087 int random6 = passConfig.Get<WorldGenRange>("CaveHouseCount").GetRandom(genRand);
12088 int random7 = passConfig.Get<WorldGenRange>("UnderworldChestCount").GetRandom(genRand);
12089 int num546 = passConfig.Get<WorldGenRange>("CaveChestCount").GetRandom(genRand);
12090 int random8 = passConfig.Get<WorldGenRange>("AdditionalDesertHouseCount").GetRandom(genRand);
12091 if (Main.starGame)
12092 {
12093 num546 = (int)((double)num546 * Main.starGameMath(0.2));
12094 }
12095 int num547 = random6 + random7 + num546 + random8;
12096 int num548 = 10000;
12097 for (int num549 = 0; num549 < num546; num549++)
12098 {
12099 if (num548 <= 0)
12100 {
12101 break;
12102 }
12103 progress.Set((double)num549 / (double)num547);
12104 int num550 = genRand.Next(20, Main.maxTilesX - 20);
12105 int num551 = genRand.Next((int)((GenVars.worldSurfaceHigh + 20.0 + Main.rockLayer) / 2.0), Main.maxTilesY - 230);
12106 if (remixWorldGen)
12107 {
12108 num551 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 400);
12109 }
12110 ushort wall = Main.tile[num550, num551].wall;
12111 if (Main.wallDungeon[wall] || wall == 87 || oceanDepths(num550, num551) || !AddBuriedChest(num550, num551, 0, notNearOtherChests: false, -1, trySlope: false, 0))
12112 {
12113 num548--;
12114 num549--;
12115 }
12116 }
12117 num548 = 10000;
12118 for (int num552 = 0; num552 < random7; num552++)
12119 {
12120 if (num548 <= 0)
12121 {
12122 break;
12123 }
12124 progress.Set((double)(num552 + num546) / (double)num547);
12125 int num553 = genRand.Next(20, Main.maxTilesX - 20);
12126 int num554 = genRand.Next(Main.UnderworldLayer, Main.maxTilesY - 50);
12127 if (Main.wallDungeon[Main.tile[num553, num554].wall] || !AddBuriedChest(num553, num554, 0, notNearOtherChests: false, -1, trySlope: false, 0))
12128 {
12129 num548--;
12130 num552--;
12131 }
12132 }
12133 num548 = 10000;
12134 for (int num555 = 0; num555 < random6; num555++)
12135 {
12136 if (num548 <= 0)
12137 {
12138 break;
12139 }
12140 progress.Set((double)(num555 + num546 + random7) / (double)num547);
12141 int x11 = genRand.Next(80, Main.maxTilesX - 80);
12142 int y9 = genRand.Next((int)(GenVars.worldSurfaceHigh + 20.0), Main.maxTilesY - 230);
12143 if (remixWorldGen)
12144 {
12145 y9 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 400);
12146 }
12147 if (oceanDepths(x11, y9) || !caveHouseBiome.Place(new Point(x11, y9), GenVars.structures))
12148 {
12149 num548--;
12150 num555--;
12151 }
12152 }
12153 num548 = 10000;
12154 Rectangle undergroundDesertHiveLocation = GenVars.UndergroundDesertHiveLocation;
12155 if ((double)undergroundDesertHiveLocation.Y < Main.worldSurface + 26.0)
12156 {
12157 int num556 = (int)Main.worldSurface + 26 - undergroundDesertHiveLocation.Y;
12158 undergroundDesertHiveLocation.Y += num556;
12159 undergroundDesertHiveLocation.Height -= num556;
12160 }
12161 for (int num557 = 0; num557 < random8; num557++)
12162 {
12163 if (num548 <= 0)
12164 {
12165 break;
12166 }
12167 progress.Set((double)(num557 + num546 + random7 + random6) / (double)num547);
12168 if (!caveHouseBiome.Place(RandomRectanglePoint(undergroundDesertHiveLocation), GenVars.structures))
12169 {
12170 num548--;
12171 num557--;
12172 }
12173 }
12174 Main.tileSolid[226] = false;
12175 Main.tileSolid[162] = false;
12176 Main.tileSolid[225] = false;
12177 });
12178 AddGenerationPass("Surface Chests", delegate(GenerationProgress progress, GameConfiguration passConfig)
12179 {
12180 progress.Message = Lang.gen[31].Value;
12181 for (int num536 = 0; num536 < (int)((double)Main.maxTilesX * 0.005); num536++)
12182 {
12183 double value8 = (double)num536 / ((double)Main.maxTilesX * 0.005);
12184 progress.Set(value8);
12185 bool flag30 = false;
12186 int num537 = 0;
12187 while (!flag30)
12188 {
12189 int num538 = genRand.Next(200, Main.maxTilesX - 200);
12190 int num539 = genRand.Next((int)GenVars.worldSurfaceLow, (int)Main.worldSurface);
12191 if (remixWorldGen)
12192 {
12193 num539 = genRand.Next(Main.maxTilesY - 400, Main.maxTilesY - 150);
12194 }
12195 else
12196 {
12197 while (oceanDepths(num538, num539))
12198 {
12199 num538 = genRand.Next(300, Main.maxTilesX - 300);
12200 num539 = genRand.Next((int)GenVars.worldSurfaceLow, (int)Main.worldSurface);
12201 }
12202 }
12203 bool flag31 = false;
12204 if (!Main.tile[num538, num539].active())
12205 {
12206 if (Main.tile[num538, num539].wall == 2 || Main.tile[num538, num539].wall == 59 || Main.tile[num538, num539].wall == 244 || remixWorldGen)
12207 {
12208 flag31 = true;
12209 }
12210 }
12211 else
12212 {
12213 int num540 = 50;
12214 int num541 = num538;
12215 int num542 = num539;
12216 int num543 = 1;
12217 for (int num544 = num541 - num540; num544 <= num541 + num540; num544 += 2)
12218 {
12219 for (int num545 = num542 - num540; num545 <= num542 + num540; num545 += 2)
12220 {
12221 if ((double)num545 < Main.worldSurface && !Main.tile[num544, num545].active() && Main.tile[num544, num545].wall == 244 && genRand.Next(num543) == 0)
12222 {
12223 num543++;
12224 flag31 = true;
12225 num538 = num544;
12226 num539 = num545;
12227 }
12228 }
12229 }
12230 }
12231 if (flag31 && AddBuriedChest(num538, num539, 0, notNearOtherChests: true, -1, trySlope: false, 0))
12232 {
12233 flag30 = true;
12234 }
12235 else
12236 {
12237 num537++;
12238 if (num537 >= 2000)
12239 {
12240 flag30 = true;
12241 }
12242 }
12243 }
12244 }
12245 });
12246 AddGenerationPass("Jungle Chests Placement", delegate(GenerationProgress progress, GameConfiguration passConfig)
12247 {
12248 progress.Message = Lang.gen[32].Value;
12249 for (int num531 = 0; num531 < GenVars.numJChests; num531++)
12250 {
12251 double value7 = (double)num531 / (double)GenVars.numJChests;
12252 progress.Set(value7);
12253 int nextJungleChestItem = GetNextJungleChestItem();
12254 if (!AddBuriedChest(GenVars.JChestX[num531] + genRand.Next(2), GenVars.JChestY[num531], nextJungleChestItem, notNearOtherChests: false, 10, trySlope: false, 0))
12255 {
12256 for (int num532 = GenVars.JChestX[num531] - 1; num532 <= GenVars.JChestX[num531] + 1; num532++)
12257 {
12258 for (int num533 = GenVars.JChestY[num531]; num533 <= GenVars.JChestY[num531] + 2; num533++)
12259 {
12260 KillTile(num532, num533);
12261 }
12262 }
12263 for (int num534 = GenVars.JChestX[num531] - 1; num534 <= GenVars.JChestX[num531] + 1; num534++)
12264 {
12265 for (int num535 = GenVars.JChestY[num531]; num535 <= GenVars.JChestY[num531] + 3; num535++)
12266 {
12267 if (num535 < Main.maxTilesY)
12268 {
12269 Main.tile[num534, num535].slope(0);
12270 Main.tile[num534, num535].halfBrick(halfBrick: false);
12271 }
12272 }
12273 }
12274 AddBuriedChest(GenVars.JChestX[num531], GenVars.JChestY[num531], nextJungleChestItem, notNearOtherChests: false, 10, trySlope: false, 0);
12275 }
12276 }
12277 });
12278 AddGenerationPass("Water Chests", delegate(GenerationProgress progress, GameConfiguration passConfig)
12279 {
12280 progress.Message = Lang.gen[33].Value;
12281 for (int num518 = 0; num518 < GenVars.numOceanCaveTreasure; num518++)
12282 {
12283 int contain = genRand.NextFromList(new short[5] { 863, 186, 277, 187, 4404 });
12284 bool flag28 = false;
12285 double num519 = 2.0;
12286 while (!flag28 && num519 < 50.0)
12287 {
12288 num519 += 0.1;
12289 int num520 = genRand.Next(GenVars.oceanCaveTreasure[num518].X - (int)num519, GenVars.oceanCaveTreasure[num518].X + (int)num519 + 1);
12290 int num521 = genRand.Next(GenVars.oceanCaveTreasure[num518].Y - (int)num519 / 2, GenVars.oceanCaveTreasure[num518].Y + (int)num519 / 2 + 1);
12291 num520 = ((num520 >= Main.maxTilesX) ? ((int)((double)num520 + num519 / 2.0)) : ((int)((double)num520 - num519 / 2.0)));
12292 if (Main.tile[num520, num521].liquid > 250 && (Main.tile[num520, num521].liquidType() == 0 || notTheBees || remixWorldGen))
12293 {
12294 flag28 = AddBuriedChest(num520, num521, contain, notNearOtherChests: false, 17, trySlope: true, 0);
12295 }
12296 }
12297 }
12298 int num522 = 0;
12299 double num523 = (double)Main.maxTilesX / 4200.0;
12300 for (int num524 = 0; (double)num524 < 9.0 * num523; num524++)
12301 {
12302 double value6 = (double)num524 / (9.0 * num523);
12303 progress.Set(value6);
12304 int num525 = 0;
12305 num522++;
12306 int maxValue8 = 10;
12307 if (tenthAnniversaryWorldGen)
12308 {
12309 maxValue8 = 7;
12310 }
12311 if (genRand.Next(maxValue8) == 0)
12312 {
12313 num525 = 863;
12314 }
12315 else
12316 {
12317 switch (num522)
12318 {
12319 case 1:
12320 num525 = 186;
12321 break;
12322 case 2:
12323 num525 = 4404;
12324 break;
12325 case 3:
12326 num525 = 277;
12327 break;
12328 default:
12329 num525 = 187;
12330 num522 = 0;
12331 break;
12332 }
12333 }
12334 bool flag29 = false;
12335 int num526 = 0;
12336 while (!flag29)
12337 {
12338 int num527 = genRand.Next(50, Main.maxTilesX - 50);
12339 int num528 = genRand.Next(1, Main.UnderworldLayer);
12340 while (Main.tile[num527, num528].liquid < 250 || (Main.tile[num527, num528].liquidType() != 0 && !notTheBees && !remixWorldGen))
12341 {
12342 num527 = genRand.Next(50, Main.maxTilesX - 50);
12343 num528 = genRand.Next(50, Main.UnderworldLayer);
12344 }
12345 flag29 = AddBuriedChest(num527, num528, num525, notNearOtherChests: false, 17, num527 < beachDistance || num527 > Main.maxTilesX - beachDistance, 0);
12346 num526++;
12347 if (num526 > 10000)
12348 {
12349 break;
12350 }
12351 }
12352 flag29 = false;
12353 num526 = 0;
12354 while (!flag29)
12355 {
12356 int num529 = genRand.Next(50, Main.maxTilesX - 50);
12357 int num530 = genRand.Next((int)Main.worldSurface, Main.UnderworldLayer);
12358 while (Main.tile[num529, num530].liquid < 250 || (Main.tile[num529, num530].liquidType() != 0 && !notTheBees))
12359 {
12360 num529 = genRand.Next(50, Main.maxTilesX - 50);
12361 num530 = genRand.Next((int)Main.worldSurface, Main.UnderworldLayer);
12362 }
12363 flag29 = AddBuriedChest(num529, num530, num525, notNearOtherChests: false, 17, num529 < beachDistance || num529 > Main.maxTilesX - beachDistance, 0);
12364 num526++;
12365 if (num526 > 10000)
12366 {
12367 break;
12368 }
12369 }
12370 }
12371 });
12372 AddGenerationPass("Spider Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
12373 {
12374 progress.Message = Lang.gen[64].Value;
12375 maxTileCount = 3500;
12376 int num513 = Main.maxTilesX / 2;
12377 int num514 = (int)((double)Main.maxTilesX * 0.005);
12378 if (getGoodWorldGen)
12379 {
12380 num514 *= 3;
12381 }
12382 if (notTheBees)
12383 {
12384 Main.tileSolid[225] = true;
12385 }
12386 for (int num515 = 0; num515 < num514; num515++)
12387 {
12388 double value5 = (double)num515 / ((double)Main.maxTilesX * 0.005);
12389 progress.Set(value5);
12390 int num516 = 0;
12391 int x10 = genRand.Next(200, Main.maxTilesX - 200);
12392 int y8 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, Main.maxTilesY - 230);
12393 if (remixWorldGen)
12394 {
12395 y8 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
12396 }
12397 int num517 = countTiles(x10, y8, jungle: false, lavaOk: true);
12398 while ((num517 >= 3500 || num517 < 500) && num516 < num513)
12399 {
12400 num516++;
12401 x10 = genRand.Next(200, Main.maxTilesX - 200);
12402 y8 = genRand.Next((int)Main.rockLayer + 30, Main.maxTilesY - 230);
12403 if (remixWorldGen)
12404 {
12405 y8 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
12406 }
12407 num517 = countTiles(x10, y8, jungle: false, lavaOk: true);
12408 if (shroomCount > 1)
12409 {
12410 num517 = 0;
12411 }
12412 }
12413 if (num516 < num513)
12414 {
12415 Spread.Spider(x10, y8);
12416 }
12417 }
12418 if (notTheBees)
12419 {
12420 Main.tileSolid[225] = false;
12421 }
12422 Main.tileSolid[162] = true;
12423 });
12424 AddGenerationPass("Gem Caves", delegate(GenerationProgress progress, GameConfiguration passConfig)
12425 {
12426 if (!notTheBees)
12427 {
12428 progress.Message = Lang.gen[64].Value;
12429 maxTileCount = 300;
12430 double num509 = (double)Main.maxTilesX * 0.003;
12431 if (tenthAnniversaryWorldGen)
12432 {
12433 num509 *= 1.5;
12434 }
12435 if (Main.starGame)
12436 {
12437 num509 *= Main.starGameMath(0.2);
12438 }
12439 for (int num510 = 0; (double)num510 < num509; num510++)
12440 {
12441 double value4 = (double)num510 / num509;
12442 progress.Set(value4);
12443 int num511 = 0;
12444 int x9 = genRand.Next(200, Main.maxTilesX - 200);
12445 int y7 = genRand.Next((int)Main.rockLayer + 30, Main.maxTilesY - 230);
12446 if (remixWorldGen)
12447 {
12448 y7 = genRand.Next((int)Main.worldSurface + 30, (int)Main.rockLayer - 30);
12449 }
12450 int num512 = countTiles(x9, y7);
12451 while ((num512 >= 300 || num512 < 50 || lavaCount > 0 || iceCount > 0 || rockCount == 0) && num511 < 1000)
12452 {
12453 num511++;
12454 x9 = genRand.Next(200, Main.maxTilesX - 200);
12455 y7 = genRand.Next((int)Main.rockLayer + 30, Main.maxTilesY - 230);
12456 if (remixWorldGen)
12457 {
12458 y7 = genRand.Next((int)Main.worldSurface + 30, (int)Main.rockLayer - 30);
12459 }
12460 num512 = countTiles(x9, y7);
12461 }
12462 if (num511 < 1000)
12463 {
12464 gemCave(x9, y7);
12465 }
12466 }
12467 }
12468 });
12469 AddGenerationPass("Moss", delegate(GenerationProgress progress, GameConfiguration passConfig)
12470 {
12471 //IL_0393: Unknown result type (might be due to invalid IL or missing references)
12472 //IL_0398: Unknown result type (might be due to invalid IL or missing references)
12473 //IL_04e7: Unknown result type (might be due to invalid IL or missing references)
12474 //IL_04ec: Unknown result type (might be due to invalid IL or missing references)
12475 //IL_05be: Unknown result type (might be due to invalid IL or missing references)
12476 //IL_05c3: Unknown result type (might be due to invalid IL or missing references)
12477 if (!notTheBees || remixWorldGen)
12478 {
12479 progress.Message = Lang.gen[61].Value;
12480 randMoss();
12481 int num479 = Main.maxTilesX / 2100;
12482 if (remixWorldGen)
12483 {
12484 num479 = (int)((double)num479 * 1.5);
12485 }
12486 else if (tenthAnniversaryWorldGen)
12487 {
12488 num479 *= 2;
12489 }
12490 int num480 = 0;
12491 int num481 = 0;
12492 while (num481 < num479)
12493 {
12494 int num482 = genRand.Next(100, Main.maxTilesX - 100);
12495 if (remixWorldGen)
12496 {
12497 num482 = genRand.Next((int)((double)Main.maxTilesX * 0.3), (int)((double)Main.maxTilesX * 0.7));
12498 }
12499 else if (tenthAnniversaryWorldGen)
12500 {
12501 if (genRand.Next(2) == 0)
12502 {
12503 randMoss(justNeon: true);
12504 }
12505 }
12506 else if (getGoodWorldGen)
12507 {
12508 while ((double)num482 > (double)Main.maxTilesX * 0.42 && (double)num482 < (double)Main.maxTilesX * 0.48)
12509 {
12510 num482 = genRand.Next(100, Main.maxTilesX - 100);
12511 }
12512 }
12513 else if (!drunkWorldGen)
12514 {
12515 while ((double)num482 > (double)Main.maxTilesX * 0.38 && (double)num482 < (double)Main.maxTilesX * 0.62)
12516 {
12517 num482 = genRand.Next(100, Main.maxTilesX - 100);
12518 }
12519 }
12520 int num483 = ((!remixWorldGen) ? genRand.Next((int)Main.rockLayer + 40, GenVars.lavaLine - 40) : genRand.Next((int)Main.worldSurface + 50, (int)Main.rockLayer - 50));
12521 bool flag27 = false;
12522 int num484 = 50;
12523 for (int num485 = num482 - num484; num485 <= num482 + num484; num485++)
12524 {
12525 for (int num486 = num483 - num484; num486 <= num483 + num484; num486++)
12526 {
12527 if (Main.tile[num485, num486].active())
12528 {
12529 int type6 = Main.tile[num485, num486].type;
12530 if (remixWorldGen)
12531 {
12532 if (type6 == 60 || type6 == 161 || type6 == 147 || Main.tileDungeon[type6] || type6 == 25 || type6 == 203)
12533 {
12534 flag27 = true;
12535 num485 = num482 + num484 + 1;
12536 break;
12537 }
12538 }
12539 else if (type6 == 70 || type6 == 60 || type6 == 367 || type6 == 368 || type6 == 161 || type6 == 147 || type6 == 396 || type6 == 397 || Main.tileDungeon[type6])
12540 {
12541 flag27 = true;
12542 num485 = num482 + num484 + 1;
12543 break;
12544 }
12545 }
12546 }
12547 }
12548 if (flag27)
12549 {
12550 num480++;
12551 if (num480 > Main.maxTilesX)
12552 {
12553 num481++;
12554 }
12555 }
12556 else
12557 {
12558 num480 = 0;
12559 num481++;
12560 int maxY = GenVars.lavaLine;
12561 if (remixWorldGen)
12562 {
12563 maxY = (int)Main.rockLayer + 50;
12564 }
12565 neonMossBiome(num482, num483, maxY);
12566 }
12567 }
12568 maxTileCount = 2500;
12569 for (int num487 = 0; num487 < (int)((double)Main.maxTilesX * 0.01); num487++)
12570 {
12571 double value3 = (double)num487 / ((double)Main.maxTilesX * 0.01);
12572 progress.Set(value3);
12573 int num488 = 0;
12574 int num489 = genRand.Next(200, Main.maxTilesX - 200);
12575 int num490 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, GenVars.waterLine);
12576 if (remixWorldGen)
12577 {
12578 num490 = genRand.Next((int)Main.worldSurface, (int)Main.rockLayer);
12579 }
12580 if (!(Vector2D.Distance(new Vector2D((double)num489, (double)num490), GenVars.shimmerPosition) < (double)shimmerSafetyDistance))
12581 {
12582 int num491 = countTiles(num489, num490);
12583 while ((num491 >= 2500 || num491 < 10 || lavaCount > 0 || iceCount > 0 || rockCount == 0 || shroomCount > 0) && num488 < 1000)
12584 {
12585 num488++;
12586 num489 = genRand.Next(200, Main.maxTilesX - 200);
12587 num490 = genRand.Next((int)Main.rockLayer + 30, Main.maxTilesY - 230);
12588 num491 = countTiles(num489, num490);
12589 }
12590 if (num488 < 1000)
12591 {
12592 setMoss(num489, num490);
12593 Spread.Moss(num489, num490);
12594 }
12595 }
12596 }
12597 for (int num492 = 0; num492 < Main.maxTilesX; num492++)
12598 {
12599 int num493 = genRand.Next(50, Main.maxTilesX - 50);
12600 int num494 = ((!remixWorldGen) ? genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, GenVars.lavaLine) : genRand.Next((int)Main.worldSurface, Main.maxTilesY - 300));
12601 if (!(Vector2D.Distance(new Vector2D((double)num493, (double)num494), GenVars.shimmerPosition) < (double)shimmerSafetyDistance) && Main.tile[num493, num494].type == 1)
12602 {
12603 setMoss(num493, num494);
12604 Main.tile[num493, num494].type = GenVars.mossTile;
12605 }
12606 }
12607 double num495 = (double)Main.maxTilesX * 0.05;
12608 while (num495 > 0.0)
12609 {
12610 int num496 = genRand.Next(50, Main.maxTilesX - 50);
12611 int num497 = ((!remixWorldGen) ? genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, GenVars.lavaLine) : genRand.Next((int)Main.worldSurface, Main.maxTilesY - 300));
12612 if (!(Vector2D.Distance(new Vector2D((double)num496, (double)num497), GenVars.shimmerPosition) < (double)shimmerSafetyDistance) && Main.tile[num496, num497].type == 1 && (!Main.tile[num496 - 1, num497].active() || !Main.tile[num496 + 1, num497].active() || !Main.tile[num496, num497 - 1].active() || !Main.tile[num496, num497 + 1].active()))
12613 {
12614 setMoss(num496, num497);
12615 Main.tile[num496, num497].type = GenVars.mossTile;
12616 num495 -= 1.0;
12617 }
12618 }
12619 num495 = (double)Main.maxTilesX * 0.065;
12620 if (remixWorldGen)
12621 {
12622 num495 *= 2.0;
12623 }
12624 while (num495 > 0.0)
12625 {
12626 int num498 = genRand.Next(50, Main.maxTilesX - 50);
12627 int num499 = ((!remixWorldGen) ? genRand.Next(GenVars.waterLine, Main.UnderworldLayer) : genRand.Next(GenVars.lavaLine, (int)Main.rockLayer + 50));
12628 if (Main.tile[num498, num499].type == 1 && (!Main.tile[num498 - 1, num499].active() || !Main.tile[num498 + 1, num499].active() || !Main.tile[num498, num499 - 1].active() || !Main.tile[num498, num499 + 1].active()))
12629 {
12630 int num500 = 25;
12631 int num501 = 0;
12632 for (int num502 = num498 - num500; num502 < num498 + num500; num502++)
12633 {
12634 for (int num503 = num499 - num500; num503 < num499 + num500; num503++)
12635 {
12636 if (Main.tile[num502, num503].liquid > 0 && Main.tile[num502, num503].lava())
12637 {
12638 num501++;
12639 }
12640 }
12641 }
12642 if (num501 > 20)
12643 {
12644 Main.tile[num498, num499].type = 381;
12645 num495 -= 1.0;
12646 }
12647 else
12648 {
12649 num495 -= 0.002;
12650 }
12651 }
12652 num495 -= 0.001;
12653 }
12654 for (int num504 = 0; num504 < Main.maxTilesX; num504++)
12655 {
12656 for (int num505 = 0; num505 < Main.maxTilesY; num505++)
12657 {
12658 if (Main.tile[num504, num505].active() && Main.tileMoss[Main.tile[num504, num505].type])
12659 {
12660 for (int num506 = 0; num506 < 4; num506++)
12661 {
12662 int num507 = num504;
12663 int num508 = num505;
12664 if (num506 == 0)
12665 {
12666 num507--;
12667 }
12668 if (num506 == 1)
12669 {
12670 num507++;
12671 }
12672 if (num506 == 2)
12673 {
12674 num508--;
12675 }
12676 if (num506 == 3)
12677 {
12678 num508++;
12679 }
12680 try
12681 {
12682 grassSpread = 0;
12683 SpreadGrass(num507, num508, 1, Main.tile[num504, num505].type);
12684 }
12685 catch
12686 {
12687 grassSpread = 0;
12688 SpreadGrass(num507, num508, 1, Main.tile[num504, num505].type, repeat: false);
12689 }
12690 }
12691 }
12692 }
12693 }
12694 }
12695 });
12696 AddGenerationPass("Temple", delegate
12697 {
12698 Main.tileSolid[162] = false;
12699 Main.tileSolid[226] = true;
12700 templePart2();
12701 Main.tileSolid[232] = false;
12702 });
12703 AddGenerationPass("Cave Walls", delegate(GenerationProgress progress, GameConfiguration passConfig)
12704 {
12705 progress.Message = Lang.gen[63].Value;
12706 maxTileCount = 1500;
12707 for (int num463 = 0; num463 < (int)((double)Main.maxTilesX * 0.04); num463++)
12708 {
12709 double num464 = (double)num463 / ((double)Main.maxTilesX * 0.04);
12710 progress.Set(num464 * 0.66);
12711 int num465 = 0;
12712 int x7 = genRand.Next(200, Main.maxTilesX - 200);
12713 int y5 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, Main.maxTilesY - 220);
12714 if (remixWorldGen)
12715 {
12716 y5 = genRand.Next((int)Main.worldSurface + 25, (int)Main.rockLayer);
12717 }
12718 int num466 = countTiles(x7, y5, jungle: false, lavaOk: true);
12719 while ((num466 >= maxTileCount || num466 < 10) && num465 < 500)
12720 {
12721 num465++;
12722 x7 = genRand.Next(200, Main.maxTilesX - 200);
12723 y5 = genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, Main.maxTilesY - 220);
12724 if (remixWorldGen)
12725 {
12726 y5 = genRand.Next((int)Main.worldSurface + 25, (int)Main.rockLayer);
12727 }
12728 num466 = countTiles(x7, y5, jungle: false, lavaOk: true);
12729 }
12730 if (num465 < 500)
12731 {
12732 int num467 = genRand.Next(2);
12733 if ((double)shroomCount > (double)rockCount * 0.75)
12734 {
12735 num467 = 80;
12736 }
12737 else if (iceCount > 0)
12738 {
12739 switch (num467)
12740 {
12741 case 0:
12742 num467 = 40;
12743 break;
12744 case 1:
12745 num467 = 71;
12746 break;
12747 }
12748 }
12749 else if (lavaCount > 0)
12750 {
12751 num467 = 79;
12752 }
12753 else
12754 {
12755 num467 = genRand.Next(4);
12756 switch (num467)
12757 {
12758 case 0:
12759 num467 = 59;
12760 break;
12761 case 1:
12762 num467 = 61;
12763 break;
12764 case 2:
12765 num467 = 170;
12766 break;
12767 case 3:
12768 num467 = 171;
12769 break;
12770 }
12771 }
12772 Spread.Wall(x7, y5, num467);
12773 }
12774 }
12775 if (remixWorldGen)
12776 {
12777 maxTileCount = 1500;
12778 for (int num468 = 0; num468 < (int)((double)Main.maxTilesX * 0.04); num468++)
12779 {
12780 double num469 = (double)num468 / ((double)Main.maxTilesX * 0.04);
12781 progress.Set(num469 * 0.66);
12782 int num470 = 0;
12783 int x8 = genRand.Next(200, Main.maxTilesX - 200);
12784 int y6 = genRand.Next((int)Main.rockLayer, Main.maxTilesY - 350);
12785 int num471 = countTiles(x8, y6, jungle: false, lavaOk: true);
12786 while ((num471 >= maxTileCount || num471 < 10) && num470 < 500)
12787 {
12788 num470++;
12789 x8 = genRand.Next(200, Main.maxTilesX - 200);
12790 y6 = genRand.Next((int)Main.rockLayer, Main.maxTilesY - 350);
12791 num471 = countTiles(x8, y6, jungle: false, lavaOk: true);
12792 }
12793 if (num470 < 500 && iceCount == 0 && lavaCount == 0 && sandCount == 0)
12794 {
12795 int wallType2 = ((genRand.Next(2) != 0) ? 63 : 2);
12796 Spread.Wall(x8, y6, wallType2);
12797 }
12798 }
12799 }
12800 maxTileCount = 1500;
12801 double num472 = (double)Main.maxTilesX * 0.02;
12802 for (int num473 = 0; (double)num473 < num472; num473++)
12803 {
12804 double num474 = (double)num473 / ((double)Main.maxTilesX * 0.02);
12805 progress.Set(num474 * 0.33 + 0.66);
12806 int num475 = 0;
12807 int num476 = genRand.Next(200, Main.maxTilesX - 200);
12808 int num477 = genRand.Next((int)Main.worldSurface, GenVars.lavaLine);
12809 int num478 = 0;
12810 if (Main.tile[num476, num477].wall == 64)
12811 {
12812 num478 = countTiles(num476, num477, jungle: true);
12813 }
12814 while ((num478 >= maxTileCount || num478 < 10) && num475 < 1000)
12815 {
12816 num475++;
12817 num476 = genRand.Next(200, Main.maxTilesX - 200);
12818 num477 = genRand.Next((int)Main.worldSurface, GenVars.lavaLine);
12819 if (!Main.wallHouse[Main.tile[num476, num477].wall] && Main.tile[num476, num477].wall != 244)
12820 {
12821 num478 = ((Main.tile[num476, num477].wall == 64) ? countTiles(num476, num477, jungle: true) : 0);
12822 }
12823 }
12824 if (num475 < 1000)
12825 {
12826 Spread.Wall2(num476, num477, 15);
12827 }
12828 }
12829 });
12830 AddGenerationPass("Jungle Trees", delegate(GenerationProgress progress, GameConfiguration passConfig)
12831 {
12832 progress.Message = Lang.gen[83].Value;
12833 for (int num461 = 0; num461 < Main.maxTilesX; num461++)
12834 {
12835 progress.Set((double)num461 / (double)Main.maxTilesX);
12836 for (int num462 = (int)Main.worldSurface - 1; num462 < Main.maxTilesY - 350; num462++)
12837 {
12838 if (genRand.Next(10) == 0 || drunkWorldGen)
12839 {
12840 GrowUndergroundTree(num461, num462);
12841 }
12842 }
12843 }
12844 });
12845 AddGenerationPass("Floating Island Houses", delegate(GenerationProgress progress, GameConfiguration passConfig)
12846 {
12847 progress.Set(1.0);
12848 for (int num460 = 0; num460 < GenVars.numIslandHouses; num460++)
12849 {
12850 if (!GenVars.skyLake[num460])
12851 {
12852 IslandHouse(GenVars.floatingIslandHouseX[num460], GenVars.floatingIslandHouseY[num460], GenVars.floatingIslandStyle[num460]);
12853 }
12854 }
12855 });
12856 AddGenerationPass("Quick Cleanup", delegate(GenerationProgress progress, GameConfiguration passConfig)
12857 {
12858 progress.Set(1.0);
12859 if (notTheBees)
12860 {
12861 NotTheBees();
12862 }
12863 Main.tileSolid[137] = false;
12864 Main.tileSolid[130] = false;
12865 for (int num453 = 20; num453 < Main.maxTilesX - 20; num453++)
12866 {
12867 for (int num454 = 20; num454 < Main.maxTilesY - 20; num454++)
12868 {
12869 if ((double)num454 < Main.worldSurface && oceanDepths(num453, num454) && Main.tile[num453, num454].type == 53 && Main.tile[num453, num454].active())
12870 {
12871 if (Main.tile[num453, num454].bottomSlope())
12872 {
12873 Main.tile[num453, num454].slope(0);
12874 }
12875 for (int num455 = num454 + 1; num455 < num454 + genRand.Next(4, 7) && (!Main.tile[num453, num455].active() || (Main.tile[num453, num455].type != 397 && Main.tile[num453, num455].type != 53)) && (!Main.tile[num453, num455 + 1].active() || (Main.tile[num453, num455 + 1].type != 397 && Main.tile[num453, num455 + 1].type != 53 && Main.tile[num453, num455 + 1].type != 495)) && (!Main.tile[num453, num455 + 2].active() || (Main.tile[num453, num455 + 2].type != 397 && Main.tile[num453, num455 + 2].type != 53 && Main.tile[num453, num455 + 2].type != 495)); num455++)
12876 {
12877 Main.tile[num453, num455].type = 0;
12878 Main.tile[num453, num455].active(active: true);
12879 Main.tile[num453, num455].halfBrick(halfBrick: false);
12880 Main.tile[num453, num455].slope(0);
12881 }
12882 }
12883 if (Main.tile[num453, num454].wall == 187 || Main.tile[num453, num454].wall == 216)
12884 {
12885 if (Main.tile[num453, num454].type == 59 || Main.tile[num453, num454].type == 123 || Main.tile[num453, num454].type == 224)
12886 {
12887 Main.tile[num453, num454].type = 397;
12888 }
12889 if (Main.tile[num453, num454].type == 368 || Main.tile[num453, num454].type == 367)
12890 {
12891 Main.tile[num453, num454].type = 397;
12892 }
12893 if ((double)num454 <= Main.rockLayer)
12894 {
12895 Main.tile[num453, num454].liquid = 0;
12896 }
12897 else if (Main.tile[num453, num454].liquid > 0)
12898 {
12899 Main.tile[num453, num454].liquid = byte.MaxValue;
12900 Main.tile[num453, num454].lava(lava: true);
12901 }
12902 }
12903 if ((double)num454 < Main.worldSurface && Main.tile[num453, num454].active() && Main.tile[num453, num454].type == 53 && Main.tile[num453, num454 + 1].wall == 0 && !SolidTile(num453, num454 + 1))
12904 {
12905 ushort num456 = 0;
12906 int num457 = 3;
12907 for (int num458 = num453 - num457; num458 <= num453 + num457; num458++)
12908 {
12909 for (int num459 = num454 - num457; num459 <= num454 + num457; num459++)
12910 {
12911 if (Main.tile[num458, num459].wall > 0)
12912 {
12913 num456 = Main.tile[num458, num459].wall;
12914 break;
12915 }
12916 }
12917 }
12918 if (num456 > 0)
12919 {
12920 Main.tile[num453, num454 + 1].wall = num456;
12921 if (Main.tile[num453, num454].wall == 0)
12922 {
12923 Main.tile[num453, num454].wall = num456;
12924 }
12925 }
12926 }
12927 if (Main.tile[num453, num454].type != 19 && TileID.Sets.CanBeClearedDuringGeneration[Main.tile[num453, num454].type])
12928 {
12929 if (Main.tile[num453, num454].topSlope() || Main.tile[num453, num454].halfBrick())
12930 {
12931 if (Main.tile[num453, num454].type != 225 || !Main.tile[num453, num454].halfBrick())
12932 {
12933 if (!SolidTile(num453, num454 + 1))
12934 {
12935 Main.tile[num453, num454].active(active: false);
12936 }
12937 if (Main.tile[num453 + 1, num454].type == 137 || Main.tile[num453 - 1, num454].type == 137)
12938 {
12939 Main.tile[num453, num454].active(active: false);
12940 }
12941 }
12942 }
12943 else if (Main.tile[num453, num454].bottomSlope())
12944 {
12945 if (!SolidTile(num453, num454 - 1))
12946 {
12947 Main.tile[num453, num454].active(active: false);
12948 }
12949 if (Main.tile[num453 + 1, num454].type == 137 || Main.tile[num453 - 1, num454].type == 137)
12950 {
12951 Main.tile[num453, num454].active(active: false);
12952 }
12953 }
12954 }
12955 }
12956 }
12957 });
12958 AddGenerationPass("Pots", delegate(GenerationProgress progress, GameConfiguration passConfig)
12959 {
12960 Main.tileSolid[137] = true;
12961 Main.tileSolid[130] = true;
12962 progress.Message = Lang.gen[35].Value;
12963 if (noTrapsWorldGen)
12964 {
12965 Main.tileSolid[138] = true;
12966 int num440 = (int)((double)(Main.maxTilesX * Main.maxTilesY) * 0.0004);
12967 if (remixWorldGen)
12968 {
12969 num440 /= 2;
12970 }
12971 for (int num441 = 0; num441 < num440; num441++)
12972 {
12973 int num442 = genRand.Next(50, Main.maxTilesX - 50);
12974 int num443;
12975 for (num443 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 250); !Main.tile[num442, num443].active() && num443 < Main.maxTilesY - 250; num443++)
12976 {
12977 }
12978 num443--;
12979 if (!Main.tile[num442, num443].shimmer())
12980 {
12981 PlaceTile(num442, num443, 138, mute: true);
12982 PlaceTile(num442 + 2, num443, 138, mute: true);
12983 PlaceTile(num442 + 1, num443 - 2, 138, mute: true);
12984 }
12985 }
12986 Main.tileSolid[138] = false;
12987 }
12988 double num444 = (double)(Main.maxTilesX * Main.maxTilesY) * 0.0008;
12989 if (Main.starGame)
12990 {
12991 num444 *= Main.starGameMath(0.2);
12992 }
12993 for (int num445 = 0; (double)num445 < num444; num445++)
12994 {
12995 double num446 = (double)num445 / num444;
12996 progress.Set(num446);
12997 bool flag25 = false;
12998 int num447 = 0;
12999 while (!flag25)
13000 {
13001 int num448 = genRand.Next((int)GenVars.worldSurfaceHigh, Main.maxTilesY - 10);
13002 if (num446 > 0.93)
13003 {
13004 num448 = Main.maxTilesY - 150;
13005 }
13006 else if (num446 > 0.75)
13007 {
13008 num448 = (int)GenVars.worldSurfaceLow;
13009 }
13010 int num449 = genRand.Next(20, Main.maxTilesX - 20);
13011 bool flag26 = false;
13012 for (int num450 = num448; num450 < Main.maxTilesY - 20; num450++)
13013 {
13014 if (!flag26)
13015 {
13016 if (Main.tile[num449, num450].active() && Main.tileSolid[Main.tile[num449, num450].type] && !Main.tile[num449, num450 - 1].lava() && !Main.tile[num449, num450 - 1].shimmer())
13017 {
13018 flag26 = true;
13019 }
13020 }
13021 else if (!((double)num450 < Main.worldSurface) || Main.tile[num449, num450].wall != 0)
13022 {
13023 int style = genRand.Next(0, 4);
13024 int num451 = 0;
13025 int num452 = 0;
13026 if (num450 < Main.maxTilesY - 5)
13027 {
13028 num451 = Main.tile[num449, num450 + 1].type;
13029 num452 = Main.tile[num449, num450].wall;
13030 }
13031 if (num451 == 147 || num451 == 161 || num451 == 162)
13032 {
13033 style = genRand.Next(4, 7);
13034 }
13035 if (num451 == 60)
13036 {
13037 style = genRand.Next(7, 10);
13038 }
13039 if (Main.wallDungeon[Main.tile[num449, num450].wall])
13040 {
13041 style = genRand.Next(10, 13);
13042 }
13043 if (num451 == 41 || num451 == 43 || num451 == 44 || num451 == 481 || num451 == 482 || num451 == 483)
13044 {
13045 style = genRand.Next(10, 13);
13046 }
13047 if (num451 == 22 || num451 == 23 || num451 == 25)
13048 {
13049 style = genRand.Next(16, 19);
13050 }
13051 if (num451 == 199 || num451 == 203 || num451 == 204 || num451 == 200)
13052 {
13053 style = genRand.Next(22, 25);
13054 }
13055 if (num451 == 367)
13056 {
13057 style = genRand.Next(31, 34);
13058 }
13059 if (num451 == 226)
13060 {
13061 style = genRand.Next(28, 31);
13062 }
13063 if (num452 == 187 || num452 == 216)
13064 {
13065 style = genRand.Next(34, 37);
13066 }
13067 if (num450 > Main.UnderworldLayer)
13068 {
13069 style = genRand.Next(13, 16);
13070 }
13071 if (!oceanDepths(num449, num450) && !Main.tile[num449, num450].shimmer() && PlacePot(num449, num450, 28, style))
13072 {
13073 flag25 = true;
13074 break;
13075 }
13076 num447++;
13077 if (num447 >= 10000)
13078 {
13079 flag25 = true;
13080 break;
13081 }
13082 }
13083 }
13084 }
13085 }
13086 });
13087 AddGenerationPass("Hellforge", delegate(GenerationProgress progress, GameConfiguration passConfig)
13088 {
13089 progress.Message = Lang.gen[36].Value;
13090 for (int num436 = 0; num436 < Main.maxTilesX / 200; num436++)
13091 {
13092 double value2 = (double)num436 / (double)(Main.maxTilesX / 200);
13093 progress.Set(value2);
13094 bool flag24 = false;
13095 int num437 = 0;
13096 while (!flag24)
13097 {
13098 int num438 = genRand.Next(1, Main.maxTilesX);
13099 int num439 = genRand.Next(Main.maxTilesY - 250, Main.maxTilesY - 30);
13100 try
13101 {
13102 if (Main.tile[num438, num439].wall == 13 || Main.tile[num438, num439].wall == 14)
13103 {
13104 for (; !Main.tile[num438, num439].active() && num439 < Main.maxTilesY - 20; num439++)
13105 {
13106 }
13107 num439--;
13108 PlaceTile(num438, num439, 77);
13109 if (Main.tile[num438, num439].type == 77)
13110 {
13111 flag24 = true;
13112 }
13113 else
13114 {
13115 num437++;
13116 if (num437 >= 10000)
13117 {
13118 flag24 = true;
13119 }
13120 }
13121 }
13122 }
13123 catch
13124 {
13125 num437++;
13126 if (num437 >= 10000)
13127 {
13128 flag24 = true;
13129 }
13130 }
13131 }
13132 }
13133 });
13134 AddGenerationPass("Spreading Grass", delegate(GenerationProgress progress, GameConfiguration passConfig)
13135 {
13136 if (!notTheBees || remixWorldGen)
13137 {
13138 progress.Message = Lang.gen[37].Value;
13139 for (int num414 = 50; num414 < Main.maxTilesX - 50; num414++)
13140 {
13141 for (int num415 = 50; (double)num415 <= Main.worldSurface; num415++)
13142 {
13143 if (Main.tile[num414, num415].active())
13144 {
13145 int type5 = Main.tile[num414, num415].type;
13146 if (Main.tile[num414, num415].active() && type5 == 60)
13147 {
13148 for (int num416 = num414 - 1; num416 <= num414 + 1; num416++)
13149 {
13150 for (int num417 = num415 - 1; num417 <= num415 + 1; num417++)
13151 {
13152 if (Main.tile[num416, num417].active() && Main.tile[num416, num417].type == 0)
13153 {
13154 if (!Main.tile[num416, num417 - 1].active())
13155 {
13156 Main.tile[num416, num417].type = 60;
13157 }
13158 else
13159 {
13160 Main.tile[num416, num417].type = 59;
13161 }
13162 }
13163 }
13164 }
13165 }
13166 else if (type5 == 1 || type5 == 40 || TileID.Sets.Ore[type5])
13167 {
13168 int num418 = 3;
13169 bool flag22 = false;
13170 ushort num419 = 0;
13171 for (int num420 = num414 - num418; num420 <= num414 + num418; num420++)
13172 {
13173 for (int num421 = num415 - num418; num421 <= num415 + num418; num421++)
13174 {
13175 if (Main.tile[num420, num421].active())
13176 {
13177 if (Main.tile[num420, num421].type == 53 || num419 == 53)
13178 {
13179 num419 = 53;
13180 }
13181 else if (Main.tile[num420, num421].type == 59 || Main.tile[num420, num421].type == 60 || Main.tile[num420, num421].type == 147 || Main.tile[num420, num421].type == 161 || Main.tile[num420, num421].type == 199 || Main.tile[num420, num421].type == 23)
13182 {
13183 num419 = Main.tile[num420, num421].type;
13184 }
13185 }
13186 else if (num421 < num415 && Main.tile[num420, num421].wall == 0)
13187 {
13188 flag22 = true;
13189 }
13190 }
13191 }
13192 if (flag22)
13193 {
13194 switch (num419)
13195 {
13196 case 23:
13197 case 199:
13198 if (Main.tile[num414, num415 - 1].active())
13199 {
13200 num419 = 0;
13201 }
13202 break;
13203 case 59:
13204 case 60:
13205 if (num414 >= GenVars.jungleMinX && num414 <= GenVars.jungleMaxX)
13206 {
13207 num419 = (ushort)(Main.tile[num414, num415 - 1].active() ? 59 : 60);
13208 }
13209 break;
13210 }
13211 Main.tile[num414, num415].type = num419;
13212 }
13213 }
13214 }
13215 }
13216 }
13217 for (int num422 = 10; num422 < Main.maxTilesX - 10; num422++)
13218 {
13219 bool flag23 = true;
13220 for (int num423 = 0; (double)num423 < Main.worldSurface - 1.0; num423++)
13221 {
13222 if (Main.tile[num422, num423].active())
13223 {
13224 if (flag23 && Main.tile[num422, num423].type == 0)
13225 {
13226 try
13227 {
13228 grassSpread = 0;
13229 SpreadGrass(num422, num423);
13230 }
13231 catch
13232 {
13233 grassSpread = 0;
13234 SpreadGrass(num422, num423, 0, 2, repeat: false);
13235 }
13236 }
13237 if ((double)num423 > GenVars.worldSurfaceHigh)
13238 {
13239 break;
13240 }
13241 flag23 = false;
13242 }
13243 else if (Main.tile[num422, num423].wall == 0)
13244 {
13245 flag23 = true;
13246 }
13247 }
13248 }
13249 if (remixWorldGen)
13250 {
13251 for (int num424 = 5; num424 < Main.maxTilesX - 5; num424++)
13252 {
13253 for (int num425 = (int)GenVars.rockLayerLow + genRand.Next(-1, 2); num425 < Main.maxTilesY - 200; num425++)
13254 {
13255 if (Main.tile[num424, num425].type == 0 && Main.tile[num424, num425].active() && (!Main.tile[num424 - 1, num425 - 1].active() || !Main.tile[num424, num425 - 1].active() || !Main.tile[num424 + 1, num425 - 1].active() || !Main.tile[num424 - 1, num425].active() || !Main.tile[num424 + 1, num425].active() || !Main.tile[num424 - 1, num425 + 1].active() || !Main.tile[num424, num425 + 1].active() || !Main.tile[num424 + 1, num425 + 1].active()))
13256 {
13257 Main.tile[num424, num425].type = 2;
13258 }
13259 }
13260 }
13261 for (int num426 = 5; num426 < Main.maxTilesX - 5; num426++)
13262 {
13263 for (int num427 = (int)GenVars.rockLayerLow + genRand.Next(-1, 2); num427 < Main.maxTilesY - 200; num427++)
13264 {
13265 if (Main.tile[num426, num427].type == 2 && !Main.tile[num426, num427 - 1].active() && genRand.Next(20) == 0)
13266 {
13267 PlaceTile(num426, num427 - 1, 27, mute: true);
13268 }
13269 }
13270 }
13271 int conversionType = 1;
13272 if (crimson)
13273 {
13274 conversionType = 4;
13275 }
13276 int num428 = Main.maxTilesX / 7;
13277 for (int num429 = 10; num429 < Main.maxTilesX - 10; num429++)
13278 {
13279 for (int num430 = 10; num430 < Main.maxTilesY - 10; num430++)
13280 {
13281 if ((double)num430 < Main.worldSurface + (double)genRand.Next(3) || num429 < num428 + genRand.Next(3) || num429 >= Main.maxTilesX - num428 - genRand.Next(3))
13282 {
13283 if (drunkWorldGen)
13284 {
13285 if (GenVars.crimsonLeft)
13286 {
13287 if (num429 < Main.maxTilesX / 2 + genRand.Next(-2, 3))
13288 {
13289 Convert(num429, num430, 4, 1);
13290 }
13291 else
13292 {
13293 Convert(num429, num430, 1, 1);
13294 }
13295 }
13296 else if (num429 < Main.maxTilesX / 2 + genRand.Next(-2, 3))
13297 {
13298 Convert(num429, num430, 1, 1);
13299 }
13300 else
13301 {
13302 Convert(num429, num430, 4, 1);
13303 }
13304 }
13305 else
13306 {
13307 Convert(num429, num430, conversionType, 1);
13308 }
13309 Main.tile[num429, num430].color(0);
13310 Main.tile[num429, num430].wallColor(0);
13311 }
13312 }
13313 }
13314 if (remixWorldGen)
13315 {
13316 Main.tileSolid[225] = true;
13317 int num431 = (int)((double)Main.maxTilesX * 0.31);
13318 int num432 = (int)((double)Main.maxTilesX * 0.69);
13319 _ = Main.maxTilesY;
13320 int num433 = Main.maxTilesY - 135;
13321 _ = Main.maxTilesY;
13322 Liquid.QuickWater(-2);
13323 for (int num434 = num431; num434 < num432 + 15; num434++)
13324 {
13325 for (int num435 = Main.maxTilesY - 200; num435 < num433; num435++)
13326 {
13327 Main.tile[num434, num435].liquid = 0;
13328 }
13329 }
13330 Main.tileSolid[225] = false;
13331 Main.tileSolid[484] = false;
13332 }
13333 }
13334 }
13335 });
13336 AddGenerationPass("Surface Ore and Stone", delegate(GenerationProgress progress, GameConfiguration passConfig)
13337 {
13338 progress.Set(1.0);
13339 int num405 = genRand.Next(Main.maxTilesX * 5 / 4200, Main.maxTilesX * 10 / 4200);
13340 for (int num406 = 0; num406 < num405; num406++)
13341 {
13342 int num407 = Main.maxTilesX / 420;
13343 while (num407 > 0)
13344 {
13345 num407--;
13346 int num408 = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
13347 while ((double)num408 >= (double)Main.maxTilesX * 0.48 && (double)num408 <= (double)Main.maxTilesX * 0.52)
13348 {
13349 num408 = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
13350 }
13351 int y3 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurface);
13352 bool flag20 = false;
13353 for (int num409 = 0; num409 < GenVars.numOrePatch; num409++)
13354 {
13355 if (Math.Abs(num408 - GenVars.orePatchX[num409]) < 200)
13356 {
13357 flag20 = true;
13358 }
13359 }
13360 if (!flag20 && OrePatch(num408, y3))
13361 {
13362 if (GenVars.numOrePatch < GenVars.maxOrePatch - 1)
13363 {
13364 GenVars.orePatchX[GenVars.numOrePatch] = num408;
13365 GenVars.numOrePatch++;
13366 }
13367 break;
13368 }
13369 }
13370 }
13371 num405 = genRand.Next(1, Main.maxTilesX * 7 / 4200);
13372 for (int num410 = 0; num410 < num405; num410++)
13373 {
13374 int num411 = Main.maxTilesX / 420;
13375 while (num411 > 0)
13376 {
13377 num411--;
13378 int num412 = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
13379 while ((double)num412 >= (double)Main.maxTilesX * 0.47 && (double)num412 <= (double)Main.maxTilesX * 0.53)
13380 {
13381 num412 = genRand.Next(beachDistance, Main.maxTilesX - beachDistance);
13382 }
13383 int y4 = genRand.Next((int)GenVars.worldSurfaceLow, (int)GenVars.worldSurface);
13384 bool flag21 = false;
13385 for (int num413 = 0; num413 < GenVars.numOrePatch; num413++)
13386 {
13387 if (Math.Abs(num412 - GenVars.orePatchX[num413]) < 100)
13388 {
13389 flag21 = true;
13390 }
13391 }
13392 if (!flag21 && StonePatch(num412, y4))
13393 {
13394 break;
13395 }
13396 }
13397 }
13398 });
13399 AddGenerationPass("Place Fallen Log", delegate(GenerationProgress progress, GameConfiguration passConfig)
13400 {
13401 progress.Message = Lang.gen[85].Value;
13402 int num391 = Main.maxTilesX / 2100;
13403 num391 = ((!remixWorldGen) ? (num391 + genRand.Next(-1, 2)) : (num391 + genRand.Next(0, 2)));
13404 for (int num392 = 0; num392 < num391; num392++)
13405 {
13406 progress.Set((double)num392 / (double)num391);
13407 int num393 = beachDistance + 20;
13408 int num394 = 50000;
13409 int num395 = 5000;
13410 while (num394 > 0)
13411 {
13412 num394--;
13413 int num396 = genRand.Next(num393, Main.maxTilesX - num393);
13414 int num397 = genRand.Next(10, (int)Main.worldSurface);
13415 if (remixWorldGen)
13416 {
13417 num397 = genRand.Next((int)GenVars.rockLayerLow, Main.maxTilesY - 350);
13418 }
13419 bool flag18 = false;
13420 if (num394 < num395)
13421 {
13422 flag18 = true;
13423 }
13424 if (num394 > num395 / 2)
13425 {
13426 while ((double)num396 > (double)Main.maxTilesX * 0.4 && (double)num396 < (double)Main.maxTilesX * 0.6)
13427 {
13428 num396 = genRand.Next(num393, Main.maxTilesX - num393);
13429 }
13430 }
13431 if (!Main.tile[num396, num397].active() && Main.tile[num396, num397].wall == 0)
13432 {
13433 bool flag19 = true;
13434 if (remixWorldGen)
13435 {
13436 for (; !Main.tile[num396, num397].active() && Main.tile[num396, num397].wall == 0 && num397 <= Main.maxTilesY - 350; num397++)
13437 {
13438 }
13439 }
13440 else
13441 {
13442 for (; !Main.tile[num396, num397].active() && Main.tile[num396, num397].wall == 0 && (double)num397 <= Main.worldSurface; num397++)
13443 {
13444 }
13445 }
13446 if ((double)num397 > Main.worldSurface - 10.0 && !remixWorldGen)
13447 {
13448 flag19 = false;
13449 }
13450 else if (!flag18)
13451 {
13452 int num398 = 50;
13453 for (int num399 = num396 - num398; num399 < num396 + num398; num399++)
13454 {
13455 if (num399 > 10 && num399 < Main.maxTilesX - 10)
13456 {
13457 for (int num400 = num397 - num398; num400 < num397 + num398; num400++)
13458 {
13459 if (num400 > 10 && num400 < Main.maxTilesY - 10)
13460 {
13461 int type4 = Main.tile[num399, num400].type;
13462 switch (type4)
13463 {
13464 case 189:
13465 flag19 = false;
13466 break;
13467 case 53:
13468 flag19 = false;
13469 break;
13470 default:
13471 if (Main.tileDungeon[type4])
13472 {
13473 flag19 = false;
13474 }
13475 else if (TileID.Sets.Crimson[type4])
13476 {
13477 flag19 = false;
13478 }
13479 else if (TileID.Sets.Corrupt[type4])
13480 {
13481 flag19 = false;
13482 }
13483 break;
13484 }
13485 }
13486 }
13487 }
13488 }
13489 if (flag19)
13490 {
13491 int num401 = 10;
13492 int num402 = 10;
13493 for (int num403 = num396 - num401; num403 < num396 + num401; num403++)
13494 {
13495 for (int num404 = num397 - num402; num404 < num397 - 1; num404++)
13496 {
13497 if (Main.tile[num403, num404].active() && Main.tileSolid[Main.tile[num403, num404].type])
13498 {
13499 flag19 = false;
13500 }
13501 if (Main.tile[num403, num404].wall != 0)
13502 {
13503 flag19 = false;
13504 }
13505 }
13506 }
13507 }
13508 }
13509 if (flag19 && (Main.tile[num396, num397 - 1].liquid == 0 || num394 < num395 / 5) && (Main.tile[num396, num397].type == 2 || (notTheBees && Main.tile[num396, num397].type == 60)) && (Main.tile[num396 - 1, num397].type == 2 || (notTheBees && Main.tile[num396 - 1, num397].type == 60)) && (Main.tile[num396 + 1, num397].type == 2 || (notTheBees && Main.tile[num396 + 1, num397].type == 60)))
13510 {
13511 num397--;
13512 PlaceTile(num396, num397, 488);
13513 if (Main.tile[num396, num397].active() && Main.tile[num396, num397].type == 488)
13514 {
13515 if (genRand.Next(2) == 0)
13516 {
13517 GenVars.logX = num396;
13518 GenVars.logY = num397;
13519 }
13520 num394 = -1;
13521 }
13522 }
13523 }
13524 }
13525 }
13526 });
13527 AddGenerationPass("Traps", delegate(GenerationProgress progress, GameConfiguration passConfig)
13528 {
13529 if (!notTheBees || noTrapsWorldGen || remixWorldGen)
13530 {
13531 placingTraps = true;
13532 progress.Message = Lang.gen[34].Value;
13533 if (noTrapsWorldGen)
13534 {
13535 progress.Message = Lang.gen[91].Value;
13536 }
13537 double num377 = (double)Main.maxTilesX * 0.05;
13538 if (noTrapsWorldGen)
13539 {
13540 num377 = ((!tenthAnniversaryWorldGen && !notTheBees) ? (num377 * 100.0) : (num377 * 5.0));
13541 }
13542 else if (getGoodWorldGen)
13543 {
13544 num377 *= 1.5;
13545 }
13546 if (Main.starGame)
13547 {
13548 num377 *= Main.starGameMath(0.2);
13549 }
13550 for (int num378 = 0; (double)num378 < num377; num378++)
13551 {
13552 progress.Set((double)num378 / num377 / 2.0);
13553 for (int num379 = 0; num379 < 1150; num379++)
13554 {
13555 if (noTrapsWorldGen)
13556 {
13557 int num380 = genRand.Next(50, Main.maxTilesX - 50);
13558 int num381 = genRand.Next(50, Main.maxTilesY - 50);
13559 if (remixWorldGen)
13560 {
13561 num381 = genRand.Next(50, Main.maxTilesY - 210);
13562 }
13563 if (((double)num381 > Main.worldSurface || Main.tile[num380, num381].wall > 0) && placeTrap(num380, num381))
13564 {
13565 break;
13566 }
13567 }
13568 else
13569 {
13570 int num382 = genRand.Next(200, Main.maxTilesX - 200);
13571 int num383 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 210);
13572 while (oceanDepths(num382, num383))
13573 {
13574 num382 = genRand.Next(200, Main.maxTilesX - 200);
13575 num383 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 210);
13576 }
13577 if (Main.tile[num382, num383].wall == 0 && placeTrap(num382, num383))
13578 {
13579 break;
13580 }
13581 }
13582 }
13583 }
13584 if (noTrapsWorldGen)
13585 {
13586 num377 = Main.maxTilesX * 3;
13587 if (Main.remixWorld)
13588 {
13589 num377 = Main.maxTilesX / 3;
13590 }
13591 if (Main.starGame)
13592 {
13593 num377 *= Main.starGameMath(0.2);
13594 }
13595 for (int num384 = 0; (double)num384 < num377; num384++)
13596 {
13597 if (Main.remixWorld)
13598 {
13599 placeTNTBarrel(genRand.Next(50, Main.maxTilesX - 50), genRand.Next((int)Main.worldSurface, (int)((double)(Main.maxTilesY - 350) + Main.rockLayer) / 2));
13600 }
13601 else
13602 {
13603 placeTNTBarrel(genRand.Next(50, Main.maxTilesX - 50), genRand.Next((int)Main.rockLayer, Main.maxTilesY - 200));
13604 }
13605 }
13606 }
13607 num377 = (double)Main.maxTilesX * 0.003;
13608 if (noTrapsWorldGen)
13609 {
13610 num377 *= 5.0;
13611 }
13612 else if (getGoodWorldGen)
13613 {
13614 num377 *= 1.5;
13615 }
13616 for (int num385 = 0; (double)num385 < num377; num385++)
13617 {
13618 progress.Set((double)num385 / num377 / 2.0 + 0.5);
13619 for (int num386 = 0; num386 < 20000; num386++)
13620 {
13621 int num387 = genRand.Next((int)((double)Main.maxTilesX * 0.15), (int)((double)Main.maxTilesX * 0.85));
13622 int num388 = genRand.Next((int)Main.worldSurface + 20, Main.maxTilesY - 210);
13623 if (Main.tile[num387, num388].wall == 187 && PlaceSandTrap(num387, num388))
13624 {
13625 break;
13626 }
13627 }
13628 }
13629 if (drunkWorldGen && !noTrapsWorldGen && !notTheBees)
13630 {
13631 for (int num389 = 0; num389 < 8; num389++)
13632 {
13633 progress.Message = Lang.gen[34].Value;
13634 num377 = 100.0;
13635 for (int num390 = 0; (double)num390 < num377; num390++)
13636 {
13637 progress.Set((double)num390 / num377);
13638 Thread.Sleep(10);
13639 }
13640 }
13641 }
13642 if (noTrapsWorldGen)
13643 {
13644 Main.tileSolid[138] = true;
13645 }
13646 placingTraps = false;
13647 }
13648 });
13649 AddGenerationPass("Piles", delegate(GenerationProgress progress, GameConfiguration passConfig)
13650 {
13651 progress.Message = Lang.gen[89].Value;
13652 Main.tileSolid[229] = false;
13653 Main.tileSolid[190] = false;
13654 Main.tileSolid[196] = false;
13655 Main.tileSolid[189] = false;
13656 Main.tileSolid[202] = false;
13657 Main.tileSolid[460] = false;
13658 Main.tileSolid[484] = false;
13659 if (noTrapsWorldGen)
13660 {
13661 Main.tileSolid[138] = false;
13662 }
13663 for (int num319 = 0; (double)num319 < (double)Main.maxTilesX * 0.06; num319++)
13664 {
13665 int num320 = Main.maxTilesX / 2;
13666 bool flag11 = false;
13667 while (!flag11 && num320 > 0)
13668 {
13669 num320--;
13670 int num321 = genRand.Next(25, Main.maxTilesX - 25);
13671 int num322 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 300);
13672 while (oceanDepths(num321, num322))
13673 {
13674 num321 = genRand.Next(25, Main.maxTilesX - 25);
13675 num322 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 300);
13676 }
13677 if (!Main.tile[num321, num322].active())
13678 {
13679 int num323 = 186;
13680 for (; !Main.tile[num321, num322 + 1].active() && num322 < Main.maxTilesY - 5; num322++)
13681 {
13682 }
13683 int num324 = genRand.Next(22);
13684 if (num324 >= 16 && num324 <= 22)
13685 {
13686 num324 = genRand.Next(22);
13687 }
13688 if ((Main.tile[num321, num322 + 1].type == 0 || Main.tile[num321, num322 + 1].type == 1 || Main.tileMoss[Main.tile[num321, num322 + 1].type]) && genRand.Next(5) == 0)
13689 {
13690 num324 = genRand.Next(23, 29);
13691 num323 = 187;
13692 }
13693 if (num322 > Main.maxTilesY - 300 || Main.wallDungeon[Main.tile[num321, num322].wall] || Main.tile[num321, num322 + 1].type == 30 || Main.tile[num321, num322 + 1].type == 19 || Main.tile[num321, num322 + 1].type == 25 || Main.tile[num321, num322 + 1].type == 203)
13694 {
13695 num324 = genRand.Next(7);
13696 num323 = 186;
13697 }
13698 if (Main.tile[num321, num322 + 1].type == 147 || Main.tile[num321, num322 + 1].type == 161 || Main.tile[num321, num322 + 1].type == 162)
13699 {
13700 num324 = genRand.Next(26, 32);
13701 num323 = 186;
13702 }
13703 if (Main.tile[num321, num322 + 1].type == 60)
13704 {
13705 num323 = 187;
13706 num324 = genRand.Next(6);
13707 }
13708 if ((Main.tile[num321, num322 + 1].type == 57 || Main.tile[num321, num322 + 1].type == 58) && genRand.Next(3) < 2)
13709 {
13710 num323 = 187;
13711 num324 = genRand.Next(6, 9);
13712 }
13713 if (Main.tile[num321, num322 + 1].type == 226)
13714 {
13715 num323 = 187;
13716 num324 = genRand.Next(18, 23);
13717 }
13718 if (Main.tile[num321, num322 + 1].type == 70)
13719 {
13720 num324 = genRand.Next(32, 35);
13721 num323 = 186;
13722 }
13723 if (Main.tile[num321, num322 + 1].type == 396 || Main.tile[num321, num322 + 1].type == 397 || Main.tile[num321, num322 + 1].type == 404)
13724 {
13725 num324 = genRand.Next(29, 35);
13726 num323 = 187;
13727 }
13728 if (Main.tile[num321, num322 + 1].type == 368)
13729 {
13730 num324 = genRand.Next(35, 41);
13731 num323 = 187;
13732 }
13733 if (Main.tile[num321, num322 + 1].type == 367)
13734 {
13735 num324 = genRand.Next(41, 47);
13736 num323 = 187;
13737 }
13738 if (num323 == 186 && num324 >= 7 && num324 <= 15 && genRand.Next(75) == 0)
13739 {
13740 num323 = 187;
13741 num324 = 17;
13742 }
13743 if (Main.wallDungeon[Main.tile[num321, num322].wall] && genRand.Next(3) != 0)
13744 {
13745 flag11 = true;
13746 }
13747 else
13748 {
13749 if (!Main.tile[num321, num322].shimmer())
13750 {
13751 PlaceTile(num321, num322, num323, mute: true, forced: false, -1, num324);
13752 }
13753 if (Main.tile[num321, num322].type == 186 || Main.tile[num321, num322].type == 187)
13754 {
13755 flag11 = true;
13756 }
13757 if (flag11 && num323 == 186 && num324 <= 7)
13758 {
13759 int num325 = genRand.Next(1, 5);
13760 for (int num326 = 0; num326 < num325; num326++)
13761 {
13762 int num327 = num321 + genRand.Next(-10, 11);
13763 int num328 = num322 - genRand.Next(5);
13764 if (!Main.tile[num327, num328].active())
13765 {
13766 for (; !Main.tile[num327, num328 + 1].active() && num328 < Main.maxTilesY - 5; num328++)
13767 {
13768 }
13769 int x3 = genRand.Next(12, 36);
13770 PlaceSmallPile(num327, num328, x3, 0, 185);
13771 }
13772 }
13773 }
13774 }
13775 }
13776 }
13777 }
13778 for (int num329 = 0; (double)num329 < (double)Main.maxTilesX * 0.01; num329++)
13779 {
13780 int num330 = Main.maxTilesX / 2;
13781 bool flag12 = false;
13782 while (!flag12 && num330 > 0)
13783 {
13784 num330--;
13785 int num331 = genRand.Next(25, Main.maxTilesX - 25);
13786 int num332 = genRand.Next(Main.maxTilesY - 300, Main.maxTilesY - 10);
13787 if (!Main.tile[num331, num332].active())
13788 {
13789 int num333 = 186;
13790 for (; !Main.tile[num331, num332 + 1].active() && num332 < Main.maxTilesY - 5; num332++)
13791 {
13792 }
13793 int num334 = genRand.Next(22);
13794 if (num334 >= 16 && num334 <= 22)
13795 {
13796 num334 = genRand.Next(22);
13797 }
13798 if (num332 > Main.maxTilesY - 300 || Main.wallDungeon[Main.tile[num331, num332].wall] || Main.tile[num331, num332 + 1].type == 30 || Main.tile[num331, num332 + 1].type == 19)
13799 {
13800 num334 = genRand.Next(7);
13801 }
13802 if ((Main.tile[num331, num332 + 1].type == 57 || Main.tile[num331, num332 + 1].type == 58) && genRand.Next(3) < 2)
13803 {
13804 num333 = 187;
13805 num334 = genRand.Next(6, 9);
13806 }
13807 if (Main.tile[num331, num332 + 1].type == 147 || Main.tile[num331, num332 + 1].type == 161 || Main.tile[num331, num332 + 1].type == 162)
13808 {
13809 num334 = genRand.Next(26, 32);
13810 }
13811 PlaceTile(num331, num332, num333, mute: true, forced: false, -1, num334);
13812 if (Main.tile[num331, num332].type == 186 || Main.tile[num331, num332].type == 187)
13813 {
13814 flag12 = true;
13815 }
13816 if (flag12 && num333 == 186 && num334 <= 7)
13817 {
13818 int num335 = genRand.Next(1, 5);
13819 for (int num336 = 0; num336 < num335; num336++)
13820 {
13821 int num337 = num331 + genRand.Next(-10, 11);
13822 int num338 = num332 - genRand.Next(5);
13823 if (!Main.tile[num337, num338].active())
13824 {
13825 for (; !Main.tile[num337, num338 + 1].active() && num338 < Main.maxTilesY - 5; num338++)
13826 {
13827 }
13828 int x4 = genRand.Next(12, 36);
13829 PlaceSmallPile(num337, num338, x4, 0, 185);
13830 }
13831 }
13832 }
13833 }
13834 }
13835 }
13836 for (int num339 = 0; (double)num339 < (double)Main.maxTilesX * 0.003; num339++)
13837 {
13838 int num340 = Main.maxTilesX / 2;
13839 bool flag13 = false;
13840 while (!flag13 && num340 > 0)
13841 {
13842 num340--;
13843 int num341 = 186;
13844 int num342 = genRand.Next(25, Main.maxTilesX - 25);
13845 int num343 = genRand.Next(10, (int)Main.worldSurface);
13846 while (oceanDepths(num342, num343))
13847 {
13848 num342 = genRand.Next(25, Main.maxTilesX - 25);
13849 num343 = genRand.Next(10, (int)Main.worldSurface);
13850 }
13851 if (!Main.tile[num342, num343].active())
13852 {
13853 for (; !Main.tile[num342, num343 + 1].active() && num343 < Main.maxTilesY - 5; num343++)
13854 {
13855 }
13856 int num344 = genRand.Next(7, 13);
13857 if (num343 > Main.maxTilesY - 300 || Main.wallDungeon[Main.tile[num342, num343].wall] || Main.tile[num342, num343 + 1].type == 30 || Main.tile[num342, num343 + 1].type == 19 || Main.tile[num342, num343 + 1].type == 25 || Main.tile[num342, num343 + 1].type == 203 || Main.tile[num342, num343 + 1].type == 234 || Main.tile[num342, num343 + 1].type == 112)
13858 {
13859 num344 = -1;
13860 }
13861 if (Main.tile[num342, num343 + 1].type == 147 || Main.tile[num342, num343 + 1].type == 161 || Main.tile[num342, num343 + 1].type == 162)
13862 {
13863 num344 = genRand.Next(26, 32);
13864 }
13865 if (Main.tile[num342, num343 + 1].type == 53)
13866 {
13867 num341 = 187;
13868 num344 = genRand.Next(52, 55);
13869 }
13870 if (Main.tile[num342, num343 + 1].type == 2 || Main.tile[num342 - 1, num343 + 1].type == 2 || Main.tile[num342 + 1, num343 + 1].type == 2)
13871 {
13872 num341 = 187;
13873 num344 = genRand.Next(14, 17);
13874 }
13875 if (Main.tile[num342, num343 + 1].type == 151 || Main.tile[num342, num343 + 1].type == 274)
13876 {
13877 num341 = 186;
13878 num344 = genRand.Next(7);
13879 }
13880 if (num344 >= 0)
13881 {
13882 PlaceTile(num342, num343, num341, mute: true, forced: false, -1, num344);
13883 }
13884 if (Main.tile[num342, num343].type == num341)
13885 {
13886 flag13 = true;
13887 }
13888 }
13889 }
13890 }
13891 for (int num345 = 0; (double)num345 < (double)Main.maxTilesX * 0.0035; num345++)
13892 {
13893 int num346 = Main.maxTilesX / 2;
13894 bool flag14 = false;
13895 while (!flag14 && num346 > 0)
13896 {
13897 num346--;
13898 int num347 = genRand.Next(25, Main.maxTilesX - 25);
13899 int num348 = genRand.Next(10, (int)Main.worldSurface);
13900 if (!Main.tile[num347, num348].active() && Main.tile[num347, num348].wall > 0)
13901 {
13902 int num349 = 186;
13903 for (; !Main.tile[num347, num348 + 1].active() && num348 < Main.maxTilesY - 5; num348++)
13904 {
13905 }
13906 int num350 = genRand.Next(7, 13);
13907 if (num348 > Main.maxTilesY - 300 || Main.wallDungeon[Main.tile[num347, num348].wall] || Main.tile[num347, num348 + 1].type == 30 || Main.tile[num347, num348 + 1].type == 19)
13908 {
13909 num350 = -1;
13910 }
13911 if (Main.tile[num347, num348 + 1].type == 25)
13912 {
13913 num350 = genRand.Next(7);
13914 }
13915 if (Main.tile[num347, num348 + 1].type == 147 || Main.tile[num347, num348 + 1].type == 161 || Main.tile[num347, num348 + 1].type == 162)
13916 {
13917 num350 = genRand.Next(26, 32);
13918 }
13919 if (Main.tile[num347, num348 + 1].type == 2 || Main.tile[num347 - 1, num348 + 1].type == 2 || Main.tile[num347 + 1, num348 + 1].type == 2)
13920 {
13921 num349 = 187;
13922 num350 = genRand.Next(14, 17);
13923 }
13924 if (Main.tile[num347, num348 + 1].type == 151 || Main.tile[num347, num348 + 1].type == 274)
13925 {
13926 num349 = 186;
13927 num350 = genRand.Next(7);
13928 }
13929 if (num350 >= 0)
13930 {
13931 PlaceTile(num347, num348, num349, mute: true, forced: false, -1, num350);
13932 }
13933 if (Main.tile[num347, num348].type == num349)
13934 {
13935 flag14 = true;
13936 }
13937 if (flag14 && num350 <= 7)
13938 {
13939 int num351 = genRand.Next(1, 5);
13940 for (int num352 = 0; num352 < num351; num352++)
13941 {
13942 int num353 = num347 + genRand.Next(-10, 11);
13943 int num354 = num348 - genRand.Next(5);
13944 if (!Main.tile[num353, num354].active())
13945 {
13946 for (; !Main.tile[num353, num354 + 1].active() && num354 < Main.maxTilesY - 5; num354++)
13947 {
13948 }
13949 int x5 = genRand.Next(12, 36);
13950 PlaceSmallPile(num353, num354, x5, 0, 185);
13951 }
13952 }
13953 }
13954 }
13955 }
13956 }
13957 for (int num355 = 0; (double)num355 < (double)Main.maxTilesX * 0.6; num355++)
13958 {
13959 int num356 = Main.maxTilesX / 2;
13960 bool flag15 = false;
13961 while (!flag15 && num356 > 0)
13962 {
13963 num356--;
13964 int num357 = genRand.Next(25, Main.maxTilesX - 25);
13965 int num358 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 20);
13966 if (Main.tile[num357, num358].wall == 87 && genRand.Next(2) == 0)
13967 {
13968 num357 = genRand.Next(25, Main.maxTilesX - 25);
13969 num358 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 20);
13970 }
13971 while (oceanDepths(num357, num358))
13972 {
13973 num357 = genRand.Next(25, Main.maxTilesX - 25);
13974 num358 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 20);
13975 }
13976 if (!Main.tile[num357, num358].active())
13977 {
13978 for (; !Main.tile[num357, num358 + 1].active() && num358 < Main.maxTilesY - 5; num358++)
13979 {
13980 }
13981 int num359 = genRand.Next(2);
13982 int num360 = genRand.Next(36);
13983 if (num360 >= 28 && num360 <= 35)
13984 {
13985 num360 = genRand.Next(36);
13986 }
13987 if (num359 == 1)
13988 {
13989 num360 = genRand.Next(25);
13990 if (num360 >= 16 && num360 <= 24)
13991 {
13992 num360 = genRand.Next(25);
13993 }
13994 }
13995 if (num358 > Main.maxTilesY - 300)
13996 {
13997 if (num359 == 0)
13998 {
13999 num360 = genRand.Next(12, 28);
14000 }
14001 if (num359 == 1)
14002 {
14003 num360 = genRand.Next(6, 16);
14004 }
14005 }
14006 if (Main.wallDungeon[Main.tile[num357, num358].wall] || Main.tile[num357, num358 + 1].type == 30 || Main.tile[num357, num358 + 1].type == 19 || Main.tile[num357, num358 + 1].type == 25 || Main.tile[num357, num358 + 1].type == 203 || Main.tile[num357, num358].wall == 87)
14007 {
14008 if (num359 == 0 && num360 < 12)
14009 {
14010 num360 += 12;
14011 }
14012 if (num359 == 1 && num360 < 6)
14013 {
14014 num360 += 6;
14015 }
14016 if (num359 == 1 && num360 >= 17)
14017 {
14018 num360 -= 10;
14019 }
14020 }
14021 if (Main.tile[num357, num358 + 1].type == 147 || Main.tile[num357, num358 + 1].type == 161 || Main.tile[num357, num358 + 1].type == 162)
14022 {
14023 if (num359 == 0 && num360 < 12)
14024 {
14025 num360 += 36;
14026 }
14027 if (num359 == 1 && num360 >= 20)
14028 {
14029 num360 += 6;
14030 }
14031 if (num359 == 1 && num360 < 6)
14032 {
14033 num360 += 25;
14034 }
14035 }
14036 if (Main.tile[num357, num358 + 1].type == 151 || Main.tile[num357, num358 + 1].type == 274)
14037 {
14038 if (num359 == 0)
14039 {
14040 num360 = genRand.Next(12, 28);
14041 }
14042 if (num359 == 1)
14043 {
14044 num360 = genRand.Next(12, 19);
14045 }
14046 }
14047 if (Main.tile[num357, num358 + 1].type == 368)
14048 {
14049 if (num359 == 0)
14050 {
14051 num360 = genRand.Next(60, 66);
14052 }
14053 if (num359 == 1)
14054 {
14055 num360 = genRand.Next(47, 53);
14056 }
14057 }
14058 if (Main.tile[num357, num358 + 1].type == 367)
14059 {
14060 if (num359 == 0)
14061 {
14062 num360 = genRand.Next(66, 72);
14063 }
14064 if (num359 == 1)
14065 {
14066 num360 = genRand.Next(53, 59);
14067 }
14068 }
14069 if (Main.wallDungeon[Main.tile[num357, num358].wall] && genRand.Next(3) != 0)
14070 {
14071 flag15 = true;
14072 }
14073 else if (!Main.tile[num357, num358].shimmer())
14074 {
14075 flag15 = PlaceSmallPile(num357, num358, num360, num359, 185);
14076 }
14077 if (flag15 && num359 == 1 && num360 >= 6 && num360 <= 15)
14078 {
14079 int num361 = genRand.Next(1, 5);
14080 for (int num362 = 0; num362 < num361; num362++)
14081 {
14082 int num363 = num357 + genRand.Next(-10, 11);
14083 int num364 = num358 - genRand.Next(5);
14084 if (!Main.tile[num363, num364].active())
14085 {
14086 for (; !Main.tile[num363, num364 + 1].active() && num364 < Main.maxTilesY - 5; num364++)
14087 {
14088 }
14089 int x6 = genRand.Next(12, 36);
14090 PlaceSmallPile(num363, num364, x6, 0, 185);
14091 }
14092 }
14093 }
14094 }
14095 }
14096 }
14097 for (int num365 = 0; (double)num365 < (double)Main.maxTilesX * 0.02; num365++)
14098 {
14099 int num366 = Main.maxTilesX / 2;
14100 bool flag16 = false;
14101 while (!flag16 && num366 > 0)
14102 {
14103 num366--;
14104 int num367 = genRand.Next(25, Main.maxTilesX - 25);
14105 int num368 = genRand.Next(15, (int)Main.worldSurface);
14106 while (oceanDepths(num367, num368))
14107 {
14108 num367 = genRand.Next(25, Main.maxTilesX - 25);
14109 num368 = genRand.Next(15, (int)Main.worldSurface);
14110 }
14111 if (!Main.tile[num367, num368].active())
14112 {
14113 for (; !Main.tile[num367, num368 + 1].active() && num368 < Main.maxTilesY - 5; num368++)
14114 {
14115 }
14116 int num369 = genRand.Next(2);
14117 int num370 = genRand.Next(11);
14118 if (num369 == 1)
14119 {
14120 num370 = genRand.Next(5);
14121 }
14122 if (Main.tile[num367, num368 + 1].type == 147 || Main.tile[num367, num368 + 1].type == 161 || Main.tile[num367, num368 + 1].type == 162)
14123 {
14124 if (num369 == 0 && num370 < 12)
14125 {
14126 num370 += 36;
14127 }
14128 if (num369 == 1 && num370 >= 20)
14129 {
14130 num370 += 6;
14131 }
14132 if (num369 == 1 && num370 < 6)
14133 {
14134 num370 += 25;
14135 }
14136 }
14137 if (Main.tile[num367, num368 + 1].type == 2 && num369 == 1)
14138 {
14139 num370 = genRand.Next(38, 41);
14140 }
14141 if (Main.tile[num367, num368 + 1].type == 151 || Main.tile[num367, num368 + 1].type == 274)
14142 {
14143 if (num369 == 0)
14144 {
14145 num370 = genRand.Next(12, 28);
14146 }
14147 if (num369 == 1)
14148 {
14149 num370 = genRand.Next(12, 19);
14150 }
14151 }
14152 if (!Main.wallDungeon[Main.tile[num367, num368].wall] && Main.tile[num367, num368 + 1].type != 30 && Main.tile[num367, num368 + 1].type != 19 && Main.tile[num367, num368 + 1].type != 41 && Main.tile[num367, num368 + 1].type != 43 && Main.tile[num367, num368 + 1].type != 44 && Main.tile[num367, num368 + 1].type != 481 && Main.tile[num367, num368 + 1].type != 482 && Main.tile[num367, num368 + 1].type != 483 && Main.tile[num367, num368 + 1].type != 45 && Main.tile[num367, num368 + 1].type != 46 && Main.tile[num367, num368 + 1].type != 47 && Main.tile[num367, num368 + 1].type != 175 && Main.tile[num367, num368 + 1].type != 176 && Main.tile[num367, num368 + 1].type != 177 && Main.tile[num367, num368 + 1].type != 53 && Main.tile[num367, num368 + 1].type != 25 && Main.tile[num367, num368 + 1].type != 203)
14153 {
14154 flag16 = PlaceSmallPile(num367, num368, num370, num369, 185);
14155 }
14156 }
14157 }
14158 }
14159 for (int num371 = 0; (double)num371 < (double)Main.maxTilesX * 0.15; num371++)
14160 {
14161 int num372 = Main.maxTilesX / 2;
14162 bool flag17 = false;
14163 while (!flag17 && num372 > 0)
14164 {
14165 num372--;
14166 int num373 = genRand.Next(25, Main.maxTilesX - 25);
14167 int num374 = genRand.Next(15, (int)Main.worldSurface);
14168 if (!Main.tile[num373, num374].active() && (Main.tile[num373, num374].wall == 2 || Main.tile[num373, num374].wall == 40))
14169 {
14170 for (; !Main.tile[num373, num374 + 1].active() && num374 < Main.maxTilesY - 5; num374++)
14171 {
14172 }
14173 int num375 = genRand.Next(2);
14174 int num376 = genRand.Next(11);
14175 if (num375 == 1)
14176 {
14177 num376 = genRand.Next(5);
14178 }
14179 if (Main.tile[num373, num374 + 1].type == 147 || Main.tile[num373, num374 + 1].type == 161 || Main.tile[num373, num374 + 1].type == 162)
14180 {
14181 if (num375 == 0 && num376 < 12)
14182 {
14183 num376 += 36;
14184 }
14185 if (num375 == 1 && num376 >= 20)
14186 {
14187 num376 += 6;
14188 }
14189 if (num375 == 1 && num376 < 6)
14190 {
14191 num376 += 25;
14192 }
14193 }
14194 if (Main.tile[num373, num374 + 1].type == 2 && num375 == 1)
14195 {
14196 num376 = genRand.Next(38, 41);
14197 }
14198 if (Main.tile[num373, num374 + 1].type == 151 || Main.tile[num373, num374 + 1].type == 274)
14199 {
14200 if (num375 == 0)
14201 {
14202 num376 = genRand.Next(12, 28);
14203 }
14204 if (num375 == 1)
14205 {
14206 num376 = genRand.Next(12, 19);
14207 }
14208 }
14209 if ((Main.tile[num373, num374].liquid != byte.MaxValue || Main.tile[num373, num374 + 1].type != 53 || Main.tile[num373, num374].wall != 0) && !Main.wallDungeon[Main.tile[num373, num374].wall] && Main.tile[num373, num374 + 1].type != 30 && Main.tile[num373, num374 + 1].type != 19 && Main.tile[num373, num374 + 1].type != 41 && Main.tile[num373, num374 + 1].type != 43 && Main.tile[num373, num374 + 1].type != 44 && Main.tile[num373, num374 + 1].type != 481 && Main.tile[num373, num374 + 1].type != 482 && Main.tile[num373, num374 + 1].type != 483 && Main.tile[num373, num374 + 1].type != 45 && Main.tile[num373, num374 + 1].type != 46 && Main.tile[num373, num374 + 1].type != 47 && Main.tile[num373, num374 + 1].type != 175 && Main.tile[num373, num374 + 1].type != 176 && Main.tile[num373, num374 + 1].type != 177 && Main.tile[num373, num374 + 1].type != 25 && Main.tile[num373, num374 + 1].type != 203)
14210 {
14211 flag17 = PlaceSmallPile(num373, num374, num376, num375, 185);
14212 }
14213 }
14214 }
14215 }
14216 Main.tileSolid[190] = true;
14217 Main.tileSolid[192] = true;
14218 Main.tileSolid[196] = true;
14219 Main.tileSolid[189] = true;
14220 Main.tileSolid[202] = true;
14221 Main.tileSolid[225] = true;
14222 Main.tileSolid[460] = true;
14223 Main.tileSolid[138] = true;
14224 });
14225 AddGenerationPass("Spawn Point", delegate(GenerationProgress progress, GameConfiguration passConfig)
14226 {
14227 progress.Set(1.0);
14228 int num310 = 5;
14229 bool flag10 = true;
14230 int num311 = Main.maxTilesX / 2;
14231 if (Main.tenthAnniversaryWorld && !remixWorldGen)
14232 {
14233 int num312 = GenVars.beachBordersWidth + 15;
14234 num311 = ((genRand.Next(2) != 0) ? (Main.maxTilesX - num312) : num312);
14235 }
14236 while (flag10)
14237 {
14238 int num313 = num311 + genRand.Next(-num310, num310 + 1);
14239 for (int num314 = 0; num314 < Main.maxTilesY; num314++)
14240 {
14241 if (Main.tile[num313, num314].active())
14242 {
14243 Main.spawnTileX = num313;
14244 Main.spawnTileY = num314;
14245 break;
14246 }
14247 }
14248 flag10 = false;
14249 num310++;
14250 if ((double)Main.spawnTileY > Main.worldSurface)
14251 {
14252 flag10 = true;
14253 }
14254 if (Main.tile[Main.spawnTileX, Main.spawnTileY - 1].liquid > 0)
14255 {
14256 flag10 = true;
14257 }
14258 }
14259 int num315 = 10;
14260 while ((double)Main.spawnTileY > Main.worldSurface)
14261 {
14262 int num316 = genRand.Next(num311 - num315, num311 + num315);
14263 for (int num317 = 0; num317 < Main.maxTilesY; num317++)
14264 {
14265 if (Main.tile[num316, num317].active())
14266 {
14267 Main.spawnTileX = num316;
14268 Main.spawnTileY = num317;
14269 break;
14270 }
14271 }
14272 num315++;
14273 }
14274 if (remixWorldGen)
14275 {
14276 int num318 = Main.maxTilesY - 10;
14277 while (SolidTile(Main.spawnTileX, num318))
14278 {
14279 num318--;
14280 }
14281 Main.spawnTileY = num318 + 1;
14282 }
14283 });
14284 AddGenerationPass("Grass Wall", delegate(GenerationProgress progress, GameConfiguration passConfig)
14285 {
14286 maxTileCount = 3500;
14287 progress.Set(1.0);
14288 for (int num298 = 50; num298 < Main.maxTilesX - 50; num298++)
14289 {
14290 for (int num299 = 0; (double)num299 < Main.worldSurface - 10.0; num299++)
14291 {
14292 if (genRand.Next(4) == 0)
14293 {
14294 bool flag8 = false;
14295 int num300 = -1;
14296 int num301 = -1;
14297 if (Main.tile[num298, num299].active() && Main.tile[num298, num299].type == 2 && (Main.tile[num298, num299].wall == 2 || Main.tile[num298, num299].wall == 63))
14298 {
14299 for (int num302 = num298 - 1; num302 <= num298 + 1; num302++)
14300 {
14301 for (int num303 = num299 - 1; num303 <= num299 + 1; num303++)
14302 {
14303 if (Main.tile[num302, num303].wall == 0 && !SolidTile(num302, num303))
14304 {
14305 flag8 = true;
14306 }
14307 }
14308 }
14309 if (flag8)
14310 {
14311 for (int num304 = num298 - 1; num304 <= num298 + 1; num304++)
14312 {
14313 for (int num305 = num299 - 1; num305 <= num299 + 1; num305++)
14314 {
14315 if ((Main.tile[num304, num305].wall == 2 || Main.tile[num304, num305].wall == 15) && !SolidTile(num304, num305))
14316 {
14317 num300 = num304;
14318 num301 = num305;
14319 }
14320 }
14321 }
14322 }
14323 }
14324 if (flag8 && num300 > -1 && num301 > -1 && countDirtTiles(num300, num301) < maxTileCount)
14325 {
14326 try
14327 {
14328 ushort wallType = 63;
14329 if (dontStarveWorldGen && genRand.Next(3) != 0)
14330 {
14331 wallType = 62;
14332 }
14333 Spread.Wall2(num300, num301, wallType);
14334 }
14335 catch
14336 {
14337 }
14338 }
14339 }
14340 }
14341 }
14342 for (int num306 = 5; num306 < Main.maxTilesX - 5; num306++)
14343 {
14344 for (int num307 = 10; (double)num307 < Main.worldSurface - 1.0; num307++)
14345 {
14346 if (Main.tile[num306, num307].wall == 63 && genRand.Next(10) == 0)
14347 {
14348 Main.tile[num306, num307].wall = 65;
14349 }
14350 if (Main.tile[num306, num307].active() && Main.tile[num306, num307].type == 0)
14351 {
14352 bool flag9 = false;
14353 for (int num308 = num306 - 1; num308 <= num306 + 1; num308++)
14354 {
14355 for (int num309 = num307 - 1; num309 <= num307 + 1; num309++)
14356 {
14357 if (Main.tile[num308, num309].wall == 63 || Main.tile[num308, num309].wall == 65)
14358 {
14359 flag9 = true;
14360 break;
14361 }
14362 }
14363 }
14364 if (flag9)
14365 {
14366 SpreadGrass(num306, num307);
14367 }
14368 }
14369 }
14370 }
14371 });
14372 AddGenerationPass("Guide", delegate(GenerationProgress progress, GameConfiguration passConfig)
14373 {
14374 progress.Set(1.0);
14375 if (Main.tenthAnniversaryWorld)
14376 {
14377 BirthdayParty.GenuineParty = true;
14378 BirthdayParty.PartyDaysOnCooldown = 5;
14379 if (getGoodWorldGen)
14380 {
14381 Main.afterPartyOfDoom = true;
14382 }
14383 int num292;
14384 if (remixWorldGen)
14385 {
14386 num292 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 441);
14387 NPC.savedTaxCollector = true;
14388 }
14389 else
14390 {
14391 num292 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 22);
14392 }
14393 Main.npc[num292].homeTileX = Main.spawnTileX;
14394 Main.npc[num292].homeTileY = Main.spawnTileY;
14395 Main.npc[num292].direction = 1;
14396 Main.npc[num292].homeless = true;
14397 Main.npc[num292].GivenName = Language.GetTextValue("GuideNames.Andrew");
14398 BirthdayParty.CelebratingNPCs.Add(num292);
14399 Point adjustedFloorPosition = GetAdjustedFloorPosition(Main.spawnTileX + 2, Main.spawnTileY);
14400 num292 = NPC.NewNPC(new EntitySource_WorldGen(), adjustedFloorPosition.X * 16, adjustedFloorPosition.Y * 16, 178);
14401 Main.npc[num292].homeTileX = adjustedFloorPosition.X;
14402 Main.npc[num292].homeTileY = adjustedFloorPosition.Y;
14403 Main.npc[num292].direction = -1;
14404 Main.npc[num292].homeless = true;
14405 Main.npc[num292].GivenName = Language.GetTextValue("SteampunkerNames.Whitney");
14406 BirthdayParty.CelebratingNPCs.Add(num292);
14407 adjustedFloorPosition = GetAdjustedFloorPosition(Main.spawnTileX - 2, Main.spawnTileY);
14408 num292 = NPC.NewNPC(new EntitySource_WorldGen(), adjustedFloorPosition.X * 16, adjustedFloorPosition.Y * 16, 663);
14409 Main.npc[num292].homeTileX = adjustedFloorPosition.X;
14410 Main.npc[num292].homeTileY = adjustedFloorPosition.Y;
14411 Main.npc[num292].direction = 1;
14412 Main.npc[num292].homeless = true;
14413 Main.npc[num292].GivenName = Language.GetTextValue("PrincessNames.Yorai");
14414 BirthdayParty.CelebratingNPCs.Add(num292);
14415 NPC.unlockedPrincessSpawn = true;
14416 adjustedFloorPosition = GetAdjustedFloorPosition(Main.spawnTileX + 4, Main.spawnTileY);
14417 num292 = NPC.NewNPC(new EntitySource_WorldGen(), adjustedFloorPosition.X * 16, adjustedFloorPosition.Y * 16, 208);
14418 Main.npc[num292].homeTileX = adjustedFloorPosition.X;
14419 Main.npc[num292].homeTileY = adjustedFloorPosition.Y;
14420 Main.npc[num292].direction = -1;
14421 Main.npc[num292].homeless = true;
14422 Main.npc[num292].GivenName = Language.GetTextValue("PartyGirlNames.Amanda");
14423 BirthdayParty.CelebratingNPCs.Add(num292);
14424 NPC.unlockedPartyGirlSpawn = true;
14425 adjustedFloorPosition = GetAdjustedFloorPosition(Main.spawnTileX - 4, Main.spawnTileY);
14426 if (Main.remixWorld)
14427 {
14428 num292 = NPC.NewNPC(new EntitySource_WorldGen(), adjustedFloorPosition.X * 16, adjustedFloorPosition.Y * 16, 681);
14429 Main.npc[num292].GivenName = Language.GetTextValue("SlimeNames_Rainbow.Slimestar");
14430 NPC.unlockedSlimeRainbowSpawn = true;
14431 }
14432 else
14433 {
14434 num292 = NPC.NewNPC(new EntitySource_WorldGen(), adjustedFloorPosition.X * 16, adjustedFloorPosition.Y * 16, 656);
14435 NPC.boughtBunny = true;
14436 Main.npc[num292].townNpcVariationIndex = 1;
14437 }
14438 Main.npc[num292].homeTileX = adjustedFloorPosition.X;
14439 Main.npc[num292].homeTileY = adjustedFloorPosition.Y;
14440 Main.npc[num292].direction = 1;
14441 Main.npc[num292].homeless = true;
14442 }
14443 else if (remixWorldGen)
14444 {
14445 int num293 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 441);
14446 Main.npc[num293].homeTileX = Main.spawnTileX;
14447 Main.npc[num293].homeTileY = Main.spawnTileY;
14448 Main.npc[num293].direction = 1;
14449 Main.npc[num293].homeless = true;
14450 NPC.savedTaxCollector = true;
14451 }
14452 else if (notTheBees)
14453 {
14454 int num294 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 17);
14455 Main.npc[num294].homeTileX = Main.spawnTileX;
14456 Main.npc[num294].homeTileY = Main.spawnTileY;
14457 Main.npc[num294].direction = 1;
14458 Main.npc[num294].homeless = true;
14459 NPC.unlockedMerchantSpawn = true;
14460 }
14461 else if (drunkWorldGen)
14462 {
14463 int num295 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 208);
14464 Main.npc[num295].homeTileX = Main.spawnTileX;
14465 Main.npc[num295].homeTileY = Main.spawnTileY;
14466 Main.npc[num295].direction = 1;
14467 Main.npc[num295].homeless = true;
14468 NPC.unlockedPartyGirlSpawn = true;
14469 }
14470 else if (getGoodWorldGen)
14471 {
14472 int num296 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 38);
14473 Main.npc[num296].homeTileX = Main.spawnTileX;
14474 Main.npc[num296].homeTileY = Main.spawnTileY;
14475 Main.npc[num296].direction = 1;
14476 Main.npc[num296].homeless = true;
14477 NPC.unlockedDemolitionistSpawn = true;
14478 }
14479 else
14480 {
14481 int num297 = NPC.NewNPC(new EntitySource_WorldGen(), Main.spawnTileX * 16, Main.spawnTileY * 16, 22);
14482 Main.npc[num297].homeTileX = Main.spawnTileX;
14483 Main.npc[num297].homeTileY = Main.spawnTileY;
14484 Main.npc[num297].direction = 1;
14485 Main.npc[num297].homeless = true;
14486 }
14487 });
14488 AddGenerationPass("Sunflowers", delegate(GenerationProgress progress, GameConfiguration passConfig)
14489 {
14490 progress.Message = Lang.gen[39].Value;
14491 double num283 = (double)Main.maxTilesX * 0.002;
14492 for (int num284 = 0; (double)num284 < num283; num284++)
14493 {
14494 progress.Set((double)num284 / num283);
14495 int num285 = 0;
14496 int num286 = 0;
14497 _ = Main.maxTilesX / 2;
14498 int num287 = genRand.Next(Main.maxTilesX);
14499 num285 = num287 - genRand.Next(10) - 7;
14500 num286 = num287 + genRand.Next(10) + 7;
14501 if (num285 < 0)
14502 {
14503 num285 = 0;
14504 }
14505 if (num286 > Main.maxTilesX - 1)
14506 {
14507 num286 = Main.maxTilesX - 1;
14508 }
14509 int num288 = 1;
14510 int num289 = (int)Main.worldSurface - 1;
14511 for (int num290 = num285; num290 < num286; num290++)
14512 {
14513 for (int num291 = num288; num291 < num289; num291++)
14514 {
14515 if (Main.tile[num290, num291].type == 2 && Main.tile[num290, num291].active() && !Main.tile[num290, num291 - 1].active())
14516 {
14517 PlaceTile(num290, num291 - 1, 27, mute: true);
14518 }
14519 if (Main.tile[num290, num291].active())
14520 {
14521 break;
14522 }
14523 }
14524 }
14525 }
14526 });
14527 AddGenerationPass("Planting Trees", delegate(GenerationProgress progress, GameConfiguration passConfig)
14528 {
14529 progress.Message = Lang.gen[40].Value;
14530 if (!drunkWorldGen && !Main.tenthAnniversaryWorld)
14531 {
14532 for (int num278 = 0; (double)num278 < (double)Main.maxTilesX * 0.003; num278++)
14533 {
14534 progress.Set((double)num278 / ((double)Main.maxTilesX * 0.003));
14535 int num279 = genRand.Next(50, Main.maxTilesX - 50);
14536 int num280 = genRand.Next(25, 50);
14537 for (int num281 = num279 - num280; num281 < num279 + num280; num281++)
14538 {
14539 for (int num282 = 20; (double)num282 < Main.worldSurface; num282++)
14540 {
14541 GrowEpicTree(num281, num282);
14542 }
14543 }
14544 }
14545 }
14546 AddTrees();
14547 });
14548 AddGenerationPass("Herbs", delegate(GenerationProgress progress, GameConfiguration passConfig)
14549 {
14550 double num276 = (double)Main.maxTilesX * 1.7;
14551 if (remixWorldGen)
14552 {
14553 num276 *= 5.0;
14554 }
14555 progress.Message = Lang.gen[41].Value;
14556 for (int num277 = 0; (double)num277 < num276; num277++)
14557 {
14558 progress.Set((double)num277 / num276);
14559 PlantAlch();
14560 }
14561 });
14562 AddGenerationPass("Dye Plants", delegate(GenerationProgress progress, GameConfiguration passConfig)
14563 {
14564 progress.Set(1.0);
14565 for (int num275 = 0; num275 < Main.maxTilesX; num275++)
14566 {
14567 plantDye(genRand.Next(100, Main.maxTilesX - 100), genRand.Next(100, Main.UnderworldLayer));
14568 }
14569 MatureTheHerbPlants();
14570 GrowGlowTulips();
14571 });
14572 AddGenerationPass("Webs And Honey", delegate(GenerationProgress progress, GameConfiguration passConfig)
14573 {
14574 progress.Set(1.0);
14575 for (int num265 = 100; num265 < Main.maxTilesX - 100; num265++)
14576 {
14577 int num266 = (int)Main.worldSurface;
14578 if (dontStarveWorldGen)
14579 {
14580 num266 = 50;
14581 }
14582 for (int num267 = num266; num267 < Main.maxTilesY - 100; num267++)
14583 {
14584 if (Main.tile[num265, num267].wall == 86)
14585 {
14586 if (Main.tile[num265, num267].liquid > 0)
14587 {
14588 Main.tile[num265, num267].honey(honey: true);
14589 }
14590 if (genRand.Next(3) == 0)
14591 {
14592 PlaceTight(num265, num267);
14593 }
14594 }
14595 if (Main.tile[num265, num267].wall == 62)
14596 {
14597 Main.tile[num265, num267].liquid = 0;
14598 Main.tile[num265, num267].lava(lava: false);
14599 }
14600 if (Main.tile[num265, num267].wall == 62 && !Main.tile[num265, num267].active() && genRand.Next(10) != 0)
14601 {
14602 int num268 = genRand.Next(2, 5);
14603 int num269 = num265 - num268;
14604 int num270 = num265 + num268;
14605 int num271 = num267 - num268;
14606 int num272 = num267 + num268;
14607 bool flag7 = false;
14608 for (int num273 = num269; num273 <= num270; num273++)
14609 {
14610 for (int num274 = num271; num274 <= num272; num274++)
14611 {
14612 if (SolidTile(num273, num274))
14613 {
14614 flag7 = true;
14615 break;
14616 }
14617 }
14618 }
14619 if (flag7)
14620 {
14621 PlaceTile(num265, num267, 51, mute: true);
14622 TileFrame(num265, num267);
14623 }
14624 }
14625 }
14626 }
14627 });
14628 AddGenerationPass("Weeds", delegate(GenerationProgress progress, GameConfiguration passConfig)
14629 {
14630 progress.Message = Lang.gen[42].Value;
14631 if (Main.halloween)
14632 {
14633 for (int num259 = 40; num259 < Main.maxTilesX - 40; num259++)
14634 {
14635 for (int num260 = 50; (double)num260 < Main.worldSurface; num260++)
14636 {
14637 if (Main.tile[num259, num260].active() && Main.tile[num259, num260].type == 2 && genRand.Next(15) == 0)
14638 {
14639 PlacePumpkin(num259, num260 - 1);
14640 int num261 = genRand.Next(5);
14641 for (int num262 = 0; num262 < num261; num262++)
14642 {
14643 GrowPumpkin(num259, num260 - 1, 254);
14644 }
14645 }
14646 }
14647 }
14648 }
14649 for (int num263 = 0; num263 < Main.maxTilesX; num263++)
14650 {
14651 progress.Set((double)num263 / (double)Main.maxTilesX);
14652 for (int num264 = 1; num264 < Main.maxTilesY; num264++)
14653 {
14654 if (Main.tile[num263, num264].type == 2 && Main.tile[num263, num264].nactive())
14655 {
14656 if (!Main.tile[num263, num264 - 1].active())
14657 {
14658 PlaceTile(num263, num264 - 1, 3, mute: true);
14659 Main.tile[num263, num264 - 1].CopyPaintAndCoating(Main.tile[num263, num264]);
14660 }
14661 }
14662 else if (Main.tile[num263, num264].type == 23 && Main.tile[num263, num264].nactive())
14663 {
14664 if (!Main.tile[num263, num264 - 1].active())
14665 {
14666 PlaceTile(num263, num264 - 1, 24, mute: true);
14667 }
14668 }
14669 else if (Main.tile[num263, num264].type == 199 && Main.tile[num263, num264].nactive())
14670 {
14671 if (!Main.tile[num263, num264 - 1].active())
14672 {
14673 PlaceTile(num263, num264 - 1, 201, mute: true);
14674 }
14675 }
14676 else if (Main.tile[num263, num264].type == 633 && Main.tile[num263, num264].nactive() && !Main.tile[num263, num264 - 1].active())
14677 {
14678 PlaceTile(num263, num264 - 1, 637, mute: true);
14679 }
14680 }
14681 }
14682 });
14683 AddGenerationPass("Glowing Mushrooms and Jungle Plants", delegate(GenerationProgress progress, GameConfiguration passConfig)
14684 {
14685 progress.Set(1.0);
14686 for (int num257 = 0; num257 < Main.maxTilesX; num257++)
14687 {
14688 for (int num258 = 0; num258 < Main.maxTilesY; num258++)
14689 {
14690 if (Main.tile[num257, num258].active())
14691 {
14692 if (num258 >= (int)Main.worldSurface && Main.tile[num257, num258].type == 70 && !Main.tile[num257, num258 - 1].active())
14693 {
14694 GrowTree(num257, num258);
14695 if (!Main.tile[num257, num258 - 1].active())
14696 {
14697 GrowTree(num257, num258);
14698 if (!Main.tile[num257, num258 - 1].active())
14699 {
14700 GrowTree(num257, num258);
14701 if (!Main.tile[num257, num258 - 1].active())
14702 {
14703 PlaceTile(num257, num258 - 1, 71, mute: true);
14704 }
14705 }
14706 }
14707 }
14708 if (Main.tile[num257, num258].type == 60 && !Main.tile[num257, num258 - 1].active())
14709 {
14710 PlaceTile(num257, num258 - 1, 61, mute: true);
14711 }
14712 }
14713 }
14714 }
14715 });
14716 AddGenerationPass("Jungle Plants", delegate(GenerationProgress progress, GameConfiguration passConfig)
14717 {
14718 progress.Set(1.0);
14719 for (int num254 = 0; num254 < Main.maxTilesX * 100; num254++)
14720 {
14721 int num255 = genRand.Next(40, Main.maxTilesX / 2 - 40);
14722 if (GenVars.dungeonSide < 0)
14723 {
14724 num255 += Main.maxTilesX / 2;
14725 }
14726 int num256;
14727 for (num256 = genRand.Next(Main.maxTilesY - 300); !Main.tile[num255, num256].active() && num256 < Main.maxTilesY - 300; num256++)
14728 {
14729 }
14730 if (Main.tile[num255, num256].active() && Main.tile[num255, num256].type == 60)
14731 {
14732 num256--;
14733 PlaceJunglePlant(num255, num256, 233, genRand.Next(8), 0);
14734 if (Main.tile[num255, num256].type != 233)
14735 {
14736 PlaceJunglePlant(num255, num256, 233, genRand.Next(12), 1);
14737 }
14738 }
14739 }
14740 });
14741 AddGenerationPass("Vines", delegate(GenerationProgress progress, GameConfiguration passConfig)
14742 {
14743 progress.Message = Lang.gen[43].Value;
14744 for (int num233 = 5; num233 < Main.maxTilesX - 5; num233++)
14745 {
14746 progress.Set((double)num233 / (double)Main.maxTilesX);
14747 int num234 = 0;
14748 ushort type3 = 52;
14749 int num235 = (int)Main.worldSurface;
14750 if (remixWorldGen)
14751 {
14752 num235 = Main.maxTilesY - 200;
14753 }
14754 for (int num236 = 0; num236 < num235; num236++)
14755 {
14756 if (num234 > 0 && !Main.tile[num233, num236].active())
14757 {
14758 Main.tile[num233, num236].active(active: true);
14759 Main.tile[num233, num236].type = type3;
14760 Main.tile[num233, num236].CopyPaintAndCoating(Main.tile[num233, num236 - 1]);
14761 num234--;
14762 }
14763 else
14764 {
14765 num234 = 0;
14766 }
14767 if (Main.tile[num233, num236].active() && !Main.tile[num233, num236].bottomSlope() && (Main.tile[num233, num236].type == 2 || (Main.tile[num233, num236].type == 192 && genRand.Next(4) == 0)) && GrowMoreVines(num233, num236))
14768 {
14769 type3 = 52;
14770 if (Main.tile[num233, num236].wall == 68 || Main.tile[num233, num236].wall == 65 || Main.tile[num233, num236].wall == 66 || Main.tile[num233, num236].wall == 63)
14771 {
14772 type3 = 382;
14773 }
14774 else if (Main.tile[num233, num236 + 1].wall == 68 || Main.tile[num233, num236 + 1].wall == 65 || Main.tile[num233, num236 + 1].wall == 66 || Main.tile[num233, num236 + 1].wall == 63)
14775 {
14776 type3 = 382;
14777 }
14778 if (remixWorldGen && genRand.Next(5) == 0)
14779 {
14780 type3 = 382;
14781 }
14782 if (genRand.Next(5) < 3)
14783 {
14784 num234 = genRand.Next(1, 10);
14785 }
14786 }
14787 }
14788 num234 = 0;
14789 for (int num237 = 5; num237 < Main.maxTilesY - 5; num237++)
14790 {
14791 if (num234 > 0 && !Main.tile[num233, num237].active())
14792 {
14793 Main.tile[num233, num237].active(active: true);
14794 Main.tile[num233, num237].type = 62;
14795 num234--;
14796 }
14797 else
14798 {
14799 num234 = 0;
14800 }
14801 if (Main.tile[num233, num237].active() && Main.tile[num233, num237].type == 60 && !Main.tile[num233, num237].bottomSlope() && GrowMoreVines(num233, num237))
14802 {
14803 if (notTheBees && num237 < Main.maxTilesY - 10 && Main.tile[num233, num237 - 1].active() && !Main.tile[num233, num237 - 1].bottomSlope() && Main.tile[num233 + 1, num237 - 1].active() && !Main.tile[num233 + 1, num237 - 1].bottomSlope() && (Main.tile[num233, num237 - 1].type == 60 || Main.tile[num233, num237 - 1].type == 444 || Main.tile[num233, num237 - 1].type == 230))
14804 {
14805 bool flag5 = true;
14806 for (int num238 = num233; num238 < num233 + 2; num238++)
14807 {
14808 for (int num239 = num237 + 1; num239 < num237 + 3; num239++)
14809 {
14810 if (Main.tile[num238, num239].active() && (!Main.tileCut[Main.tile[num238, num239].type] || Main.tile[num238, num239].type == 444))
14811 {
14812 flag5 = false;
14813 break;
14814 }
14815 if (Main.tile[num238, num239].liquid > 0 || Main.wallHouse[Main.tile[num238, num239].wall])
14816 {
14817 flag5 = false;
14818 break;
14819 }
14820 }
14821 if (!flag5)
14822 {
14823 break;
14824 }
14825 }
14826 if (flag5 && CountNearBlocksTypes(num233, num237, genRand.Next(3, 10), 1, 444) > 0)
14827 {
14828 flag5 = false;
14829 }
14830 if (flag5)
14831 {
14832 for (int num240 = num233; num240 < num233 + 2; num240++)
14833 {
14834 for (int num241 = num237 + 1; num241 < num237 + 3; num241++)
14835 {
14836 KillTile(num240, num241);
14837 }
14838 }
14839 for (int num242 = num233; num242 < num233 + 2; num242++)
14840 {
14841 for (int num243 = num237 + 1; num243 < num237 + 3; num243++)
14842 {
14843 Main.tile[num242, num243].active(active: true);
14844 Main.tile[num242, num243].type = 444;
14845 Main.tile[num242, num243].frameX = (short)((num242 - num233) * 18);
14846 Main.tile[num242, num243].frameY = (short)((num243 - num237 - 1) * 18);
14847 }
14848 }
14849 continue;
14850 }
14851 }
14852 else if (num233 < Main.maxTilesX - 1 && num237 < Main.maxTilesY - 2 && Main.tile[num233 + 1, num237].active() && Main.tile[num233 + 1, num237].type == 60 && !Main.tile[num233 + 1, num237].bottomSlope() && genRand.Next(40) == 0)
14853 {
14854 bool flag6 = true;
14855 for (int num244 = num233; num244 < num233 + 2; num244++)
14856 {
14857 for (int num245 = num237 + 1; num245 < num237 + 3; num245++)
14858 {
14859 if (Main.tile[num244, num245].active() && (!Main.tileCut[Main.tile[num244, num245].type] || Main.tile[num244, num245].type == 444))
14860 {
14861 flag6 = false;
14862 break;
14863 }
14864 if (Main.tile[num244, num245].liquid > 0 || Main.wallHouse[Main.tile[num244, num245].wall])
14865 {
14866 flag6 = false;
14867 break;
14868 }
14869 }
14870 if (!flag6)
14871 {
14872 break;
14873 }
14874 }
14875 if (flag6 && CountNearBlocksTypes(num233, num237, 20, 1, 444) > 0)
14876 {
14877 flag6 = false;
14878 }
14879 if (flag6)
14880 {
14881 for (int num246 = num233; num246 < num233 + 2; num246++)
14882 {
14883 for (int num247 = num237 + 1; num247 < num237 + 3; num247++)
14884 {
14885 KillTile(num246, num247);
14886 }
14887 }
14888 for (int num248 = num233; num248 < num233 + 2; num248++)
14889 {
14890 for (int num249 = num237 + 1; num249 < num237 + 3; num249++)
14891 {
14892 Main.tile[num248, num249].active(active: true);
14893 Main.tile[num248, num249].type = 444;
14894 Main.tile[num248, num249].frameX = (short)((num248 - num233) * 18);
14895 Main.tile[num248, num249].frameY = (short)((num249 - num237 - 1) * 18);
14896 }
14897 }
14898 continue;
14899 }
14900 }
14901 if (genRand.Next(5) < 3)
14902 {
14903 num234 = genRand.Next(1, 10);
14904 }
14905 }
14906 }
14907 num234 = 0;
14908 for (int num250 = 0; num250 < Main.maxTilesY; num250++)
14909 {
14910 if (num234 > 0 && !Main.tile[num233, num250].active())
14911 {
14912 Main.tile[num233, num250].active(active: true);
14913 Main.tile[num233, num250].type = 528;
14914 num234--;
14915 }
14916 else
14917 {
14918 num234 = 0;
14919 }
14920 if (Main.tile[num233, num250].active() && Main.tile[num233, num250].type == 70 && genRand.Next(5) == 0 && !Main.tile[num233, num250].bottomSlope() && GrowMoreVines(num233, num250) && genRand.Next(5) < 3)
14921 {
14922 num234 = genRand.Next(1, 10);
14923 }
14924 }
14925 num234 = 0;
14926 for (int num251 = 0; num251 < Main.maxTilesY; num251++)
14927 {
14928 if (num234 > 0 && !Main.tile[num233, num251].active())
14929 {
14930 Main.tile[num233, num251].active(active: true);
14931 Main.tile[num233, num251].type = 636;
14932 num234--;
14933 }
14934 else
14935 {
14936 num234 = 0;
14937 }
14938 if (Main.tile[num233, num251].active() && !Main.tile[num233, num251].bottomSlope() && Main.tile[num233, num251].type == 23 && GrowMoreVines(num233, num251) && genRand.Next(5) < 3)
14939 {
14940 num234 = genRand.Next(1, 10);
14941 }
14942 }
14943 num234 = 0;
14944 for (int num252 = 0; num252 < Main.maxTilesY; num252++)
14945 {
14946 if (num234 > 0 && !Main.tile[num233, num252].active())
14947 {
14948 Main.tile[num233, num252].active(active: true);
14949 Main.tile[num233, num252].type = 205;
14950 num234--;
14951 }
14952 else
14953 {
14954 num234 = 0;
14955 }
14956 if (Main.tile[num233, num252].active() && !Main.tile[num233, num252].bottomSlope() && Main.tile[num233, num252].type == 199 && GrowMoreVines(num233, num252) && genRand.Next(5) < 3)
14957 {
14958 num234 = genRand.Next(1, 10);
14959 }
14960 }
14961 num234 = 0;
14962 for (int num253 = 0; num253 < Main.maxTilesY; num253++)
14963 {
14964 if (num234 > 0 && !Main.tile[num233, num253].active())
14965 {
14966 Main.tile[num233, num253].active(active: true);
14967 Main.tile[num233, num253].type = 638;
14968 num234--;
14969 }
14970 else
14971 {
14972 num234 = 0;
14973 }
14974 if (Main.tile[num233, num253].active() && !Main.tile[num233, num253].bottomSlope() && Main.tile[num233, num253].type == 633 && GrowMoreVines(num233, num253) && genRand.Next(5) < 3)
14975 {
14976 num234 = genRand.Next(1, 10);
14977 }
14978 }
14979 }
14980 });
14981 AddGenerationPass("Flowers", delegate(GenerationProgress progress, GameConfiguration passConfig)
14982 {
14983 progress.Message = Lang.gen[44].Value;
14984 int num220 = (int)((double)Main.maxTilesX * 0.004);
14985 if (remixWorldGen)
14986 {
14987 num220 *= 6;
14988 }
14989 for (int num221 = 0; num221 < num220; num221++)
14990 {
14991 progress.Set((double)num221 / (double)num220);
14992 int num222 = genRand.Next(100, Main.maxTilesX - 100);
14993 int num223 = genRand.Next(15, 30);
14994 int num224 = genRand.Next(15, 30);
14995 if (remixWorldGen)
14996 {
14997 num223 = genRand.Next(15, 45);
14998 num224 = genRand.Next(15, 45);
14999 int num225 = genRand.Next((int)Main.rockLayer, Main.maxTilesY - 350);
15000 if (GenVars.logX >= 0)
15001 {
15002 num222 = GenVars.logX;
15003 num225 = GenVars.logY;
15004 GenVars.logX = -1;
15005 }
15006 int num226 = genRand.NextFromList<int>(21, 24, 27, 30, 33, 36, 39, 42);
15007 for (int num227 = num222 - num223; num227 < num222 + num223; num227++)
15008 {
15009 for (int num228 = num225 - num224; num228 < num225 + num224; num228++)
15010 {
15011 if (Main.tile[num227, num228].type != 488 && !Main.tileSolid[Main.tile[num227, num228].type])
15012 {
15013 if (Main.tile[num227, num228].type == 3)
15014 {
15015 Main.tile[num227, num228].frameX = (short)((num226 + genRand.Next(3)) * 18);
15016 if (genRand.Next(3) != 0)
15017 {
15018 Main.tile[num227, num228].type = 73;
15019 }
15020 }
15021 else if (Main.tile[num227, num228 + 1].wall == 0 && (Main.tile[num227, num228 + 1].type == 2 || ((Main.tile[num227, num228 + 1].type == 40 || Main.tile[num227, num228 + 1].type == 1 || TileID.Sets.Ore[Main.tile[num227, num228 + 1].type]) && !Main.tile[num227, num228].active())) && (!Main.tile[num227, num228].active() || Main.tile[num227, num228].type == 185 || Main.tile[num227, num228].type == 186 || Main.tile[num227, num228].type == 187 || (Main.tile[num227, num228].type == 5 && (double)num227 < (double)Main.maxTilesX * 0.48) || (double)num227 > (double)Main.maxTilesX * 0.52))
15022 {
15023 if (Main.tile[num227, num228 + 1].type == 40 || Main.tile[num227, num228 + 1].type == 1 || TileID.Sets.Ore[Main.tile[num227, num228 + 1].type])
15024 {
15025 Main.tile[num227, num228 + 1].type = 2;
15026 if (Main.tile[num227, num228 + 2].type == 40 || Main.tile[num227, num228 + 2].type == 1 || TileID.Sets.Ore[Main.tile[num227, num228 + 2].type])
15027 {
15028 Main.tile[num227, num228 + 2].type = 2;
15029 }
15030 }
15031 KillTile(num227, num228);
15032 if (genRand.Next(2) == 0)
15033 {
15034 Main.tile[num227, num228 + 1].slope(0);
15035 Main.tile[num227, num228 + 1].halfBrick(halfBrick: false);
15036 }
15037 PlaceTile(num227, num228, 3);
15038 if (Main.tile[num227, num228].active() && Main.tile[num227, num228].type == 3)
15039 {
15040 Main.tile[num227, num228].frameX = (short)((num226 + genRand.Next(3)) * 18);
15041 if (genRand.Next(3) != 0)
15042 {
15043 Main.tile[num227, num228].type = 73;
15044 }
15045 }
15046 if (Main.tile[num227, num228 + 2].type == 40 || Main.tile[num227, num228 + 2].type == 1 || TileID.Sets.Ore[Main.tile[num227, num228 + 2].type])
15047 {
15048 Main.tile[num227, num228 + 2].type = 0;
15049 }
15050 }
15051 }
15052 }
15053 }
15054 }
15055 else
15056 {
15057 for (int num229 = num224; (double)num229 < Main.worldSurface - (double)num224 - 1.0; num229++)
15058 {
15059 if (Main.tile[num222, num229].active())
15060 {
15061 if (GenVars.logX >= 0)
15062 {
15063 num222 = GenVars.logX;
15064 num229 = GenVars.logY;
15065 GenVars.logX = -1;
15066 }
15067 int num230 = genRand.NextFromList<int>(21, 24, 27, 30, 33, 36, 39, 42);
15068 for (int num231 = num222 - num223; num231 < num222 + num223; num231++)
15069 {
15070 for (int num232 = num229 - num224; num232 < num229 + num224; num232++)
15071 {
15072 if (Main.tile[num231, num232].type != 488 && !Main.tileSolid[Main.tile[num231, num232].type])
15073 {
15074 if (Main.tile[num231, num232].type == 3)
15075 {
15076 Main.tile[num231, num232].frameX = (short)((num230 + genRand.Next(3)) * 18);
15077 if (genRand.Next(3) != 0)
15078 {
15079 Main.tile[num231, num232].type = 73;
15080 }
15081 }
15082 else if (Main.tile[num231, num232 + 1].wall == 0 && (Main.tile[num231, num232 + 1].type == 2 || ((Main.tile[num231, num232 + 1].type == 40 || Main.tile[num231, num232 + 1].type == 1 || TileID.Sets.Ore[Main.tile[num231, num232 + 1].type]) && !Main.tile[num231, num232].active())) && (!Main.tile[num231, num232].active() || Main.tile[num231, num232].type == 185 || Main.tile[num231, num232].type == 186 || Main.tile[num231, num232].type == 187 || (Main.tile[num231, num232].type == 5 && (double)num231 < (double)Main.maxTilesX * 0.48) || (double)num231 > (double)Main.maxTilesX * 0.52))
15083 {
15084 if (Main.tile[num231, num232 + 1].type == 40 || Main.tile[num231, num232 + 1].type == 1 || TileID.Sets.Ore[Main.tile[num231, num232 + 1].type])
15085 {
15086 Main.tile[num231, num232 + 1].type = 2;
15087 if (Main.tile[num231, num232 + 2].type == 40 || Main.tile[num231, num232 + 2].type == 1 || TileID.Sets.Ore[Main.tile[num231, num232 + 2].type])
15088 {
15089 Main.tile[num231, num232 + 2].type = 2;
15090 }
15091 }
15092 KillTile(num231, num232);
15093 if (genRand.Next(2) == 0)
15094 {
15095 Main.tile[num231, num232 + 1].slope(0);
15096 Main.tile[num231, num232 + 1].halfBrick(halfBrick: false);
15097 }
15098 PlaceTile(num231, num232, 3);
15099 if (Main.tile[num231, num232].active() && Main.tile[num231, num232].type == 3)
15100 {
15101 Main.tile[num231, num232].frameX = (short)((num230 + genRand.Next(3)) * 18);
15102 if (genRand.Next(3) != 0)
15103 {
15104 Main.tile[num231, num232].type = 73;
15105 }
15106 }
15107 if (Main.tile[num231, num232 + 2].type == 40 || Main.tile[num231, num232 + 2].type == 1 || TileID.Sets.Ore[Main.tile[num231, num232 + 2].type])
15108 {
15109 Main.tile[num231, num232 + 2].type = 0;
15110 }
15111 }
15112 }
15113 }
15114 }
15115 break;
15116 }
15117 }
15118 }
15119 }
15120 });
15121 AddGenerationPass("Mushrooms", delegate(GenerationProgress progress, GameConfiguration passConfig)
15122 {
15123 progress.Message = Lang.gen[45].Value;
15124 int num209 = (int)((double)Main.maxTilesX * 0.002);
15125 if (remixWorldGen)
15126 {
15127 num209 *= 9;
15128 }
15129 for (int num210 = 0; num210 < num209; num210++)
15130 {
15131 progress.Set((double)num210 / (double)num209);
15132 int num211 = genRand.Next(20, Main.maxTilesX - 20);
15133 int num212 = genRand.Next(4, 10);
15134 int num213 = genRand.Next(15, 30);
15135 if (remixWorldGen)
15136 {
15137 num212 = genRand.Next(8, 17);
15138 num213 = genRand.Next(8, 17);
15139 int num214 = genRand.Next((int)Main.rockLayer, Main.maxTilesY - 350);
15140 if (Main.tile[num211, num214].active())
15141 {
15142 for (int num215 = num211 - num212; num215 < num211 + num212; num215++)
15143 {
15144 for (int num216 = num214 - num213; num216 < num214 + num213; num216++)
15145 {
15146 if (num215 < 10)
15147 {
15148 break;
15149 }
15150 if (num216 < 0)
15151 {
15152 break;
15153 }
15154 if (num215 > Main.maxTilesX - 10)
15155 {
15156 break;
15157 }
15158 if (num216 > Main.maxTilesY - 10)
15159 {
15160 break;
15161 }
15162 if (Main.tile[num215, num216].type == 3 || Main.tile[num215, num216].type == 24)
15163 {
15164 Main.tile[num215, num216].frameX = 144;
15165 }
15166 else if (Main.tile[num215, num216].type == 201)
15167 {
15168 Main.tile[num215, num216].frameX = 270;
15169 }
15170 }
15171 }
15172 }
15173 }
15174 else
15175 {
15176 for (int num217 = 1; (double)num217 < Main.worldSurface - 1.0; num217++)
15177 {
15178 if (Main.tile[num211, num217].active())
15179 {
15180 for (int num218 = num211 - num212; num218 < num211 + num212; num218++)
15181 {
15182 for (int num219 = num217 - num213; num219 < num217 + num213; num219++)
15183 {
15184 if (num218 < 10)
15185 {
15186 break;
15187 }
15188 if (num219 < 0)
15189 {
15190 break;
15191 }
15192 if (num218 > Main.maxTilesX - 10)
15193 {
15194 break;
15195 }
15196 if (num219 > Main.maxTilesY - 10)
15197 {
15198 break;
15199 }
15200 if (Main.tile[num218, num219].type == 3 || Main.tile[num218, num219].type == 24)
15201 {
15202 Main.tile[num218, num219].frameX = 144;
15203 }
15204 else if (Main.tile[num218, num219].type == 201)
15205 {
15206 Main.tile[num218, num219].frameX = 270;
15207 }
15208 }
15209 }
15210 break;
15211 }
15212 }
15213 }
15214 }
15215 });
15216 AddGenerationPass("Gems In Ice Biome", delegate(GenerationProgress progress, GameConfiguration passConfig)
15217 {
15218 progress.Set(1.0);
15219 for (int num198 = 0; (double)num198 < (double)Main.maxTilesX * 0.25; num198++)
15220 {
15221 int num199 = ((!remixWorldGen) ? genRand.Next((int)(Main.worldSurface + Main.rockLayer) / 2, GenVars.lavaLine) : genRand.Next((int)Main.worldSurface, Main.maxTilesY - 300));
15222 int num200 = genRand.Next(GenVars.snowMinX[num199], GenVars.snowMaxX[num199]);
15223 if (Main.tile[num200, num199].active() && (Main.tile[num200, num199].type == 147 || Main.tile[num200, num199].type == 161 || Main.tile[num200, num199].type == 162 || Main.tile[num200, num199].type == 224))
15224 {
15225 int num201 = genRand.Next(1, 4);
15226 int num202 = genRand.Next(1, 4);
15227 int num203 = genRand.Next(1, 4);
15228 int num204 = genRand.Next(1, 4);
15229 int num205 = genRand.Next(12);
15230 int num206 = 0;
15231 num206 = ((num205 >= 3) ? ((num205 < 6) ? 1 : ((num205 < 8) ? 2 : ((num205 < 10) ? 3 : ((num205 >= 11) ? 5 : 4)))) : 0);
15232 for (int num207 = num200 - num201; num207 < num200 + num202; num207++)
15233 {
15234 for (int num208 = num199 - num203; num208 < num199 + num204; num208++)
15235 {
15236 if (!Main.tile[num207, num208].active())
15237 {
15238 PlaceTile(num207, num208, 178, mute: true, forced: false, -1, num206);
15239 }
15240 }
15241 }
15242 }
15243 }
15244 });
15245 AddGenerationPass("Random Gems", delegate(GenerationProgress progress, GameConfiguration passConfig)
15246 {
15247 progress.Set(1.0);
15248 for (int num184 = 0; num184 < Main.maxTilesX; num184++)
15249 {
15250 int num185 = genRand.Next(20, Main.maxTilesX - 20);
15251 int num186 = genRand.Next((int)Main.rockLayer, Main.maxTilesY - 300);
15252 if (!Main.tile[num185, num186].active() && !Main.tile[num185, num186].lava() && !Main.wallDungeon[Main.tile[num185, num186].wall] && Main.tile[num185, num186].wall != 27)
15253 {
15254 int num187 = genRand.Next(12);
15255 int num188 = 0;
15256 num188 = ((num187 >= 3) ? ((num187 < 6) ? 1 : ((num187 < 8) ? 2 : ((num187 < 10) ? 3 : ((num187 >= 11) ? 5 : 4)))) : 0);
15257 PlaceTile(num185, num186, 178, mute: true, forced: false, -1, num188);
15258 }
15259 }
15260 for (int num189 = 0; num189 < Main.maxTilesX; num189++)
15261 {
15262 int num190 = genRand.Next(20, Main.maxTilesX - 20);
15263 int num191 = genRand.Next((int)Main.worldSurface, Main.maxTilesY - 300);
15264 if (!Main.tile[num190, num191].active() && !Main.tile[num190, num191].lava() && (Main.tile[num190, num191].wall == 216 || Main.tile[num190, num191].wall == 187))
15265 {
15266 int num192 = genRand.Next(1, 4);
15267 int num193 = genRand.Next(1, 4);
15268 int num194 = genRand.Next(1, 4);
15269 int num195 = genRand.Next(1, 4);
15270 for (int num196 = num190 - num192; num196 < num190 + num193; num196++)
15271 {
15272 for (int num197 = num191 - num194; num197 < num191 + num195; num197++)
15273 {
15274 if (!Main.tile[num196, num197].active())
15275 {
15276 PlaceTile(num196, num197, 178, mute: true, forced: false, -1, 6);
15277 }
15278 }
15279 }
15280 }
15281 }
15282 });
15283 AddGenerationPass("Moss Grass", delegate(GenerationProgress progress, GameConfiguration passConfig)
15284 {
15285 progress.Set(1.0);
15286 for (int num179 = 5; num179 < Main.maxTilesX - 5; num179++)
15287 {
15288 for (int num180 = 5; num180 < Main.maxTilesY - 5; num180++)
15289 {
15290 if (Main.tile[num179, num180].active() && Main.tileMoss[Main.tile[num179, num180].type])
15291 {
15292 for (int num181 = 0; num181 < 4; num181++)
15293 {
15294 int num182 = num179;
15295 int num183 = num180;
15296 if (num181 == 0)
15297 {
15298 num182--;
15299 }
15300 if (num181 == 1)
15301 {
15302 num182++;
15303 }
15304 if (num181 == 2)
15305 {
15306 num183--;
15307 }
15308 if (num181 == 3)
15309 {
15310 num183++;
15311 }
15312 if (!Main.tile[num182, num183].active())
15313 {
15314 PlaceTile(num182, num183, 184, mute: true);
15315 }
15316 }
15317 }
15318 }
15319 }
15320 });
15321 AddGenerationPass("Muds Walls In Jungle", delegate(GenerationProgress progress, GameConfiguration passConfig)
15322 {
15323 progress.Set(1.0);
15324 int num171 = 0;
15325 int num172 = 0;
15326 bool flag4 = false;
15327 for (int num173 = 5; num173 < Main.maxTilesX - 5; num173++)
15328 {
15329 for (int num174 = 0; (double)num174 < Main.worldSurface + 20.0; num174++)
15330 {
15331 if (Main.tile[num173, num174].active() && Main.tile[num173, num174].type == 60)
15332 {
15333 num171 = num173;
15334 flag4 = true;
15335 break;
15336 }
15337 }
15338 if (flag4)
15339 {
15340 break;
15341 }
15342 }
15343 flag4 = false;
15344 for (int num175 = Main.maxTilesX - 5; num175 > 5; num175--)
15345 {
15346 for (int num176 = 0; (double)num176 < Main.worldSurface + 20.0; num176++)
15347 {
15348 if (Main.tile[num175, num176].active() && Main.tile[num175, num176].type == 60)
15349 {
15350 num172 = num175;
15351 flag4 = true;
15352 break;
15353 }
15354 }
15355 if (flag4)
15356 {
15357 break;
15358 }
15359 }
15360 GenVars.jungleMinX = num171;
15361 GenVars.jungleMaxX = num172;
15362 for (int num177 = num171; num177 <= num172; num177++)
15363 {
15364 for (int num178 = 0; (double)num178 < Main.worldSurface + 20.0; num178++)
15365 {
15366 if (((num177 >= num171 + 2 && num177 <= num172 - 2) || genRand.Next(2) != 0) && ((num177 >= num171 + 3 && num177 <= num172 - 3) || genRand.Next(3) != 0) && (Main.tile[num177, num178].wall == 2 || Main.tile[num177, num178].wall == 59))
15367 {
15368 Main.tile[num177, num178].wall = 15;
15369 }
15370 }
15371 }
15372 });
15373 AddGenerationPass("Larva", delegate(GenerationProgress progress, GameConfiguration passConfig)
15374 {
15375 Main.tileSolid[229] = true;
15376 progress.Set(1.0);
15377 for (int num166 = 0; num166 < GenVars.numLarva; num166++)
15378 {
15379 int num167 = GenVars.larvaX[num166];
15380 int num168 = GenVars.larvaY[num166];
15381 for (int num169 = num167 - 1; num169 <= num167 + 1; num169++)
15382 {
15383 for (int num170 = num168 - 2; num170 <= num168 + 1; num170++)
15384 {
15385 if (num170 != num168 + 1)
15386 {
15387 Main.tile[num169, num170].active(active: false);
15388 }
15389 else
15390 {
15391 Main.tile[num169, num170].active(active: true);
15392 Main.tile[num169, num170].type = 225;
15393 Main.tile[num169, num170].slope(0);
15394 Main.tile[num169, num170].halfBrick(halfBrick: false);
15395 }
15396 }
15397 }
15398 PlaceTile(num167, num168, 231, mute: true);
15399 }
15400 Main.tileSolid[232] = true;
15401 Main.tileSolid[162] = true;
15402 });
15403 AddGenerationPass("Settle Liquids Again", delegate(GenerationProgress progress, GameConfiguration passConfig)
15404 {
15405 if (getGoodWorldGen)
15406 {
15407 Main.tileSolid[56] = true;
15408 }
15409 progress.Message = Lang.gen[27].Value;
15410 if (notTheBees)
15411 {
15412 NotTheBees();
15413 }
15414 Liquid.worldGenTilesIgnoreWater(ignoreSolids: true);
15415 Liquid.QuickWater(3);
15416 WaterCheck();
15417 int num160 = 0;
15418 Liquid.quickSettle = true;
15419 int num161 = 10;
15420 while (num160 < num161)
15421 {
15422 int num162 = Liquid.numLiquid + LiquidBuffer.numLiquidBuffer;
15423 num160++;
15424 double num163 = 0.0;
15425 int num164 = num162 * 5;
15426 while (Liquid.numLiquid > 0)
15427 {
15428 num164--;
15429 if (num164 < 0)
15430 {
15431 break;
15432 }
15433 double num165 = (double)(num162 - (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer)) / (double)num162;
15434 if (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer > num162)
15435 {
15436 num162 = Liquid.numLiquid + LiquidBuffer.numLiquidBuffer;
15437 }
15438 if (num165 > num163)
15439 {
15440 num163 = num165;
15441 }
15442 else
15443 {
15444 num165 = num163;
15445 }
15446 if (num160 == 1)
15447 {
15448 progress.Set(num165 / 3.0 + 0.33);
15449 }
15450 Liquid.UpdateLiquid();
15451 }
15452 WaterCheck();
15453 progress.Set((double)num160 / (double)num161 / 3.0 + 0.66);
15454 }
15455 Liquid.quickSettle = false;
15456 Liquid.worldGenTilesIgnoreWater(ignoreSolids: false);
15457 Main.tileSolid[484] = false;
15458 });
15459 AddGenerationPass("Cactus, Palm Trees, & Coral", delegate(GenerationProgress progress, GameConfiguration passConfig)
15460 {
15461 progress.Message = Lang.gen[38].Value;
15462 int num132 = 8;
15463 if (remixWorldGen)
15464 {
15465 num132 = 2;
15466 }
15467 int num133 = 400;
15468 int num134 = genRand.Next(3, 13);
15469 int num135 = genRand.Next(3, 13);
15470 int num136 = genRand.Next(2, 6);
15471 int num137 = genRand.Next(2, 6);
15472 int num138 = 380;
15473 for (int num139 = 0; num139 < GenVars.numOasis; num139++)
15474 {
15475 int num140 = (int)((double)GenVars.oasisWidth[num139] * 1.5);
15476 for (int num141 = GenVars.oasisPosition[num139].X - num140; num141 <= GenVars.oasisPosition[num139].X + num140; num141++)
15477 {
15478 for (int num142 = GenVars.oasisPosition[num139].Y - GenVars.oasisHeight; num142 <= GenVars.oasisPosition[num139].Y + GenVars.oasisHeight; num142++)
15479 {
15480 double num143 = 1.0;
15481 int num144 = 8;
15482 for (int num145 = num141 - num144; num145 <= num141 + num144; num145++)
15483 {
15484 for (int num146 = num142 - num144; num146 <= num142 + num144; num146++)
15485 {
15486 if (InWorld(num145, num146) && Main.tile[num145, num146] != null && Main.tile[num145, num146].active() && Main.tile[num145, num146].type == 323)
15487 {
15488 num143 = 0.13;
15489 }
15490 }
15491 }
15492 if (genRand.NextDouble() < num143)
15493 {
15494 GrowPalmTree(num141, num142);
15495 }
15496 if (PlantSeaOat(num141, num142))
15497 {
15498 if (genRand.Next(2) == 0)
15499 {
15500 GrowSeaOat(num141, num142);
15501 }
15502 if (genRand.Next(2) == 0)
15503 {
15504 GrowSeaOat(num141, num142);
15505 }
15506 }
15507 PlaceOasisPlant(num141, num142, 530);
15508 }
15509 }
15510 }
15511 for (int num147 = 0; num147 < 3; num147++)
15512 {
15513 progress.Set((double)num147 / 3.0);
15514 int num148;
15515 int num149;
15516 bool flag3;
15517 int maxValue4;
15518 switch (num147)
15519 {
15520 default:
15521 num148 = 5;
15522 num149 = num138;
15523 flag3 = false;
15524 maxValue4 = num134;
15525 break;
15526 case 1:
15527 num148 = num133;
15528 num149 = Main.maxTilesX - num133;
15529 flag3 = true;
15530 maxValue4 = num132;
15531 break;
15532 case 2:
15533 num148 = Main.maxTilesX - num138;
15534 num149 = Main.maxTilesX - 5;
15535 flag3 = false;
15536 maxValue4 = num135;
15537 break;
15538 }
15539 double num150 = Main.worldSurface - 1.0;
15540 if (remixWorldGen)
15541 {
15542 num150 = Main.maxTilesY - 50;
15543 }
15544 for (int num151 = num148; num151 < num149; num151++)
15545 {
15546 if (genRand.Next(maxValue4) == 0)
15547 {
15548 for (int num152 = 0; (double)num152 < num150; num152++)
15549 {
15550 Tile tile4 = Main.tile[num151, num152];
15551 if (tile4.active() && (tile4.type == 53 || tile4.type == 112 || tile4.type == 234))
15552 {
15553 Tile tile5 = Main.tile[num151, num152 - 1];
15554 if (!tile5.active() && tile5.wall == 0)
15555 {
15556 if (flag3)
15557 {
15558 if (remixWorldGen)
15559 {
15560 if ((double)num152 > Main.worldSurface)
15561 {
15562 if (SolidTile(num151, num152) && Main.tile[num151, num152 + 1].type == 53 && Main.tile[num151, num152 + 2].type == 53)
15563 {
15564 int maxValue5 = 3;
15565 GrowPalmTree(num151, num152);
15566 if (!Main.tile[num151, num152 - 1].active() && genRand.Next(maxValue5) == 0)
15567 {
15568 PlantCactus(num151, num152);
15569 }
15570 }
15571 }
15572 else
15573 {
15574 int num153 = 0;
15575 for (int num154 = num151 - cactusWaterWidth; num154 < num151 + cactusWaterWidth; num154++)
15576 {
15577 for (int num155 = num152 - cactusWaterHeight; num155 < num152 + cactusWaterHeight; num155++)
15578 {
15579 num153 += Main.tile[num154, num155].liquid;
15580 }
15581 }
15582 if (num153 / 255 > cactusWaterLimit)
15583 {
15584 int maxValue6 = 4;
15585 if (genRand.Next(maxValue6) == 0)
15586 {
15587 GrowPalmTree(num151, num152);
15588 }
15589 }
15590 else
15591 {
15592 PlantCactus(num151, num152);
15593 }
15594 }
15595 }
15596 else
15597 {
15598 int num156 = 0;
15599 for (int num157 = num151 - cactusWaterWidth; num157 < num151 + cactusWaterWidth; num157++)
15600 {
15601 for (int num158 = num152 - cactusWaterHeight; num158 < num152 + cactusWaterHeight; num158++)
15602 {
15603 num156 += Main.tile[num157, num158].liquid;
15604 }
15605 }
15606 if (num156 / 255 > cactusWaterLimit)
15607 {
15608 int maxValue7 = 4;
15609 if (genRand.Next(maxValue7) == 0)
15610 {
15611 GrowPalmTree(num151, num152);
15612 }
15613 }
15614 else
15615 {
15616 PlantCactus(num151, num152);
15617 }
15618 }
15619 }
15620 else
15621 {
15622 if (Main.tile[num151, num152 - 2].liquid == byte.MaxValue && Main.tile[num151, num152 - 3].liquid == byte.MaxValue && Main.tile[num151, num152 - 4].liquid == byte.MaxValue)
15623 {
15624 if (genRand.Next(2) == 0)
15625 {
15626 PlaceTile(num151, num152 - 1, 81, mute: true);
15627 }
15628 else
15629 {
15630 PlaceTile(num151, num152 - 1, 324, mute: true, forced: false, -1, RollRandomSeaShellStyle());
15631 }
15632 break;
15633 }
15634 if (Main.tile[num151, num152 - 2].liquid == 0 && (double)num152 < Main.worldSurface)
15635 {
15636 PlaceTile(num151, num152 - 1, 324, mute: true, forced: false, -1, RollRandomSeaShellStyle());
15637 break;
15638 }
15639 }
15640 }
15641 }
15642 }
15643 }
15644 else
15645 {
15646 for (int num159 = 0; (double)num159 < num150; num159++)
15647 {
15648 if (PlantSeaOat(num151, num159))
15649 {
15650 if (genRand.Next(2) == 0)
15651 {
15652 GrowSeaOat(num151, num159);
15653 }
15654 if (genRand.Next(2) == 0)
15655 {
15656 GrowSeaOat(num151, num159);
15657 }
15658 }
15659 PlaceOasisPlant(num151, num159, 530);
15660 }
15661 }
15662 }
15663 }
15664 });
15665 AddGenerationPass("Tile Cleanup", delegate(GenerationProgress progress, GameConfiguration passConfig)
15666 {
15667 progress.Message = Lang.gen[84].Value;
15668 for (int num64 = 40; num64 < Main.maxTilesX - 40; num64++)
15669 {
15670 progress.Set((double)(num64 - 40) / (double)(Main.maxTilesX - 80));
15671 for (int num65 = 40; num65 < Main.maxTilesY - 40; num65++)
15672 {
15673 if (Main.tile[num64, num65].active() && Main.tile[num64, num65].topSlope() && ((Main.tile[num64, num65].leftSlope() && Main.tile[num64 + 1, num65].halfBrick()) || (Main.tile[num64, num65].rightSlope() && Main.tile[num64 - 1, num65].halfBrick())))
15674 {
15675 Main.tile[num64, num65].slope(0);
15676 Main.tile[num64, num65].halfBrick(halfBrick: true);
15677 }
15678 if (Main.tile[num64, num65].active() && Main.tile[num64, num65].liquid > 0 && TileID.Sets.SlowlyDiesInWater[Main.tile[num64, num65].type])
15679 {
15680 KillTile(num64, num65);
15681 }
15682 if (!Main.tile[num64, num65].active() && Main.tile[num64, num65].liquid == 0 && genRand.Next(3) != 0 && SolidTile(num64, num65 - 1))
15683 {
15684 int num66 = genRand.Next(15, 21);
15685 for (int num67 = num65 - 2; num67 >= num65 - num66; num67--)
15686 {
15687 if (Main.tile[num64, num67].liquid >= 128 && !Main.tile[num64, num67].shimmer())
15688 {
15689 int num68 = 373;
15690 if (Main.tile[num64, num67].lava())
15691 {
15692 num68 = 374;
15693 }
15694 else if (Main.tile[num64, num67].honey())
15695 {
15696 num68 = 375;
15697 }
15698 int maxValue3 = num65 - num67;
15699 if (genRand.Next(maxValue3) <= 1)
15700 {
15701 if (Main.tile[num64, num65].wall == 86)
15702 {
15703 num68 = 375;
15704 }
15705 Main.tile[num64, num65].type = (ushort)num68;
15706 Main.tile[num64, num65].frameX = 0;
15707 Main.tile[num64, num65].frameY = 0;
15708 Main.tile[num64, num65].active(active: true);
15709 break;
15710 }
15711 }
15712 }
15713 if (!Main.tile[num64, num65].active())
15714 {
15715 num66 = genRand.Next(3, 11);
15716 for (int num69 = num65 + 1; num69 <= num65 + num66; num69++)
15717 {
15718 if (Main.tile[num64, num69].liquid >= 200 && !Main.tile[num64, num69].shimmer())
15719 {
15720 int num70 = 373;
15721 if (Main.tile[num64, num69].lava())
15722 {
15723 num70 = 374;
15724 }
15725 else if (Main.tile[num64, num69].honey())
15726 {
15727 num70 = 375;
15728 }
15729 int num71 = num69 - num65;
15730 if (genRand.Next(num71 * 3) <= 1)
15731 {
15732 Main.tile[num64, num65].type = (ushort)num70;
15733 Main.tile[num64, num65].frameX = 0;
15734 Main.tile[num64, num65].frameY = 0;
15735 Main.tile[num64, num65].active(active: true);
15736 break;
15737 }
15738 }
15739 }
15740 }
15741 if (!Main.tile[num64, num65].active() && genRand.Next(4) == 0)
15742 {
15743 Tile tile3 = Main.tile[num64, num65 - 1];
15744 if (TileID.Sets.Conversion.Sandstone[tile3.type] || TileID.Sets.Conversion.HardenedSand[tile3.type])
15745 {
15746 Main.tile[num64, num65].type = 461;
15747 Main.tile[num64, num65].frameX = 0;
15748 Main.tile[num64, num65].frameY = 0;
15749 Main.tile[num64, num65].active(active: true);
15750 }
15751 }
15752 }
15753 if (Main.tile[num64, num65].type == 137)
15754 {
15755 int num72 = Main.tile[num64, num65].frameY / 18;
15756 if (num72 <= 2 || num72 == 5)
15757 {
15758 int num73 = -1;
15759 if (Main.tile[num64, num65].frameX >= 18)
15760 {
15761 num73 = 1;
15762 }
15763 if (Main.tile[num64 + num73, num65].halfBrick() || Main.tile[num64 + num73, num65].slope() != 0)
15764 {
15765 Main.tile[num64 + num73, num65].active(active: false);
15766 }
15767 }
15768 }
15769 else if (Main.tile[num64, num65].type == 162 && Main.tile[num64, num65 + 1].liquid == 0 && CanKillTile(num64, num65))
15770 {
15771 Main.tile[num64, num65].active(active: false);
15772 }
15773 if (Main.tile[num64, num65].wall == 13 || Main.tile[num64, num65].wall == 14)
15774 {
15775 Main.tile[num64, num65].liquid = 0;
15776 }
15777 if (Main.tile[num64, num65].type == 31)
15778 {
15779 int num74 = Main.tile[num64, num65].frameX / 18;
15780 int num75 = 0;
15781 int num76 = num64;
15782 num75 += num74 / 2;
15783 num75 = ((!drunkWorldGen) ? (crimson ? 1 : 0) : ((Main.tile[num64, num65].wall == 83) ? 1 : 0));
15784 num74 %= 2;
15785 num76 -= num74;
15786 int num77 = Main.tile[num64, num65].frameY / 18;
15787 int num78 = 0;
15788 int num79 = num65;
15789 num78 += num77 / 2;
15790 num77 %= 2;
15791 num79 -= num77;
15792 for (int num80 = 0; num80 < 2; num80++)
15793 {
15794 for (int num81 = 0; num81 < 2; num81++)
15795 {
15796 int num82 = num76 + num80;
15797 int num83 = num79 + num81;
15798 Main.tile[num82, num83].active(active: true);
15799 Main.tile[num82, num83].slope(0);
15800 Main.tile[num82, num83].halfBrick(halfBrick: false);
15801 Main.tile[num82, num83].type = 31;
15802 Main.tile[num82, num83].frameX = (short)(num80 * 18 + 36 * num75);
15803 Main.tile[num82, num83].frameY = (short)(num81 * 18 + 36 * num78);
15804 }
15805 }
15806 }
15807 if (Main.tile[num64, num65].type == 12)
15808 {
15809 int num84 = Main.tile[num64, num65].frameX / 18;
15810 int num85 = 0;
15811 int num86 = num64;
15812 num85 += num84 / 2;
15813 num84 %= 2;
15814 num86 -= num84;
15815 int num87 = Main.tile[num64, num65].frameY / 18;
15816 int num88 = 0;
15817 int num89 = num65;
15818 num88 += num87 / 2;
15819 num87 %= 2;
15820 num89 -= num87;
15821 for (int num90 = 0; num90 < 2; num90++)
15822 {
15823 for (int num91 = 0; num91 < 2; num91++)
15824 {
15825 int num92 = num86 + num90;
15826 int num93 = num89 + num91;
15827 Main.tile[num92, num93].active(active: true);
15828 Main.tile[num92, num93].slope(0);
15829 Main.tile[num92, num93].halfBrick(halfBrick: false);
15830 Main.tile[num92, num93].type = 12;
15831 Main.tile[num92, num93].frameX = (short)(num90 * 18 + 36 * num85);
15832 Main.tile[num92, num93].frameY = (short)(num91 * 18 + 36 * num88);
15833 }
15834 if (!Main.tile[num90, num65 + 2].active())
15835 {
15836 Main.tile[num90, num65 + 2].active(active: true);
15837 if (!Main.tileSolid[Main.tile[num90, num65 + 2].type] || Main.tileSolidTop[Main.tile[num90, num65 + 2].type])
15838 {
15839 Main.tile[num90, num65 + 2].type = 0;
15840 }
15841 }
15842 Main.tile[num90, num65 + 2].slope(0);
15843 Main.tile[num90, num65 + 2].halfBrick(halfBrick: false);
15844 }
15845 }
15846 if (Main.tile[num64, num65].type == 639)
15847 {
15848 int num94 = Main.tile[num64, num65].frameX / 18;
15849 int num95 = 0;
15850 int num96 = num64;
15851 num95 += num94 / 2;
15852 num94 %= 2;
15853 num96 -= num94;
15854 int num97 = Main.tile[num64, num65].frameY / 18;
15855 int num98 = 0;
15856 int num99 = num65;
15857 num98 += num97 / 2;
15858 num97 %= 2;
15859 num99 -= num97;
15860 for (int num100 = 0; num100 < 2; num100++)
15861 {
15862 for (int num101 = 0; num101 < 2; num101++)
15863 {
15864 int num102 = num96 + num100;
15865 int num103 = num99 + num101;
15866 Main.tile[num102, num103].active(active: true);
15867 Main.tile[num102, num103].slope(0);
15868 Main.tile[num102, num103].halfBrick(halfBrick: false);
15869 Main.tile[num102, num103].type = 639;
15870 Main.tile[num102, num103].frameX = (short)(num100 * 18 + 36 * num95);
15871 Main.tile[num102, num103].frameY = (short)(num101 * 18 + 36 * num98);
15872 }
15873 if (!Main.tile[num100, num65 + 2].active())
15874 {
15875 Main.tile[num100, num65 + 2].active(active: true);
15876 if (!Main.tileSolid[Main.tile[num100, num65 + 2].type] || Main.tileSolidTop[Main.tile[num100, num65 + 2].type])
15877 {
15878 Main.tile[num100, num65 + 2].type = 0;
15879 }
15880 }
15881 Main.tile[num100, num65 + 2].slope(0);
15882 Main.tile[num100, num65 + 2].halfBrick(halfBrick: false);
15883 }
15884 }
15885 if (TileID.Sets.BasicChest[Main.tile[num64, num65].type])
15886 {
15887 int num104 = Main.tile[num64, num65].frameX / 18;
15888 int num105 = 0;
15889 ushort type2 = 21;
15890 int num106 = num64;
15891 int num107 = num65 - Main.tile[num64, num65].frameY / 18;
15892 if (Main.tile[num64, num65].type == 467)
15893 {
15894 type2 = 467;
15895 }
15896 while (num104 >= 2)
15897 {
15898 num105++;
15899 num104 -= 2;
15900 }
15901 num106 -= num104;
15902 int num108 = Chest.FindChest(num106, num107);
15903 if (num108 != -1)
15904 {
15905 switch (Main.chest[num108].item[0].type)
15906 {
15907 case 1156:
15908 num105 = 23;
15909 break;
15910 case 1571:
15911 num105 = 24;
15912 break;
15913 case 1569:
15914 num105 = 25;
15915 break;
15916 case 1260:
15917 num105 = 26;
15918 break;
15919 case 1572:
15920 num105 = 27;
15921 break;
15922 }
15923 }
15924 for (int num109 = 0; num109 < 2; num109++)
15925 {
15926 for (int num110 = 0; num110 < 2; num110++)
15927 {
15928 int num111 = num106 + num109;
15929 int num112 = num107 + num110;
15930 Main.tile[num111, num112].active(active: true);
15931 Main.tile[num111, num112].slope(0);
15932 Main.tile[num111, num112].halfBrick(halfBrick: false);
15933 Main.tile[num111, num112].type = type2;
15934 Main.tile[num111, num112].frameX = (short)(num109 * 18 + 36 * num105);
15935 Main.tile[num111, num112].frameY = (short)(num110 * 18);
15936 }
15937 if (!Main.tile[num109, num65 + 2].active())
15938 {
15939 Main.tile[num109, num65 + 2].active(active: true);
15940 if (!Main.tileSolid[Main.tile[num109, num65 + 2].type] || Main.tileSolidTop[Main.tile[num109, num65 + 2].type])
15941 {
15942 Main.tile[num109, num65 + 2].type = 0;
15943 }
15944 }
15945 Main.tile[num109, num65 + 2].slope(0);
15946 Main.tile[num109, num65 + 2].halfBrick(halfBrick: false);
15947 }
15948 }
15949 if (Main.tile[num64, num65].type == 28)
15950 {
15951 int num113 = Main.tile[num64, num65].frameX / 18;
15952 int num114 = 0;
15953 int num115 = num64;
15954 while (num113 >= 2)
15955 {
15956 num114++;
15957 num113 -= 2;
15958 }
15959 num115 -= num113;
15960 int num116 = Main.tile[num64, num65].frameY / 18;
15961 int num117 = 0;
15962 int num118 = num65;
15963 while (num116 >= 2)
15964 {
15965 num117++;
15966 num116 -= 2;
15967 }
15968 num118 -= num116;
15969 for (int num119 = 0; num119 < 2; num119++)
15970 {
15971 for (int num120 = 0; num120 < 2; num120++)
15972 {
15973 int num121 = num115 + num119;
15974 int num122 = num118 + num120;
15975 Main.tile[num121, num122].active(active: true);
15976 Main.tile[num121, num122].slope(0);
15977 Main.tile[num121, num122].halfBrick(halfBrick: false);
15978 Main.tile[num121, num122].type = 28;
15979 Main.tile[num121, num122].frameX = (short)(num119 * 18 + 36 * num114);
15980 Main.tile[num121, num122].frameY = (short)(num120 * 18 + 36 * num117);
15981 }
15982 if (!Main.tile[num119, num65 + 2].active())
15983 {
15984 Main.tile[num119, num65 + 2].active(active: true);
15985 if (!Main.tileSolid[Main.tile[num119, num65 + 2].type] || Main.tileSolidTop[Main.tile[num119, num65 + 2].type])
15986 {
15987 Main.tile[num119, num65 + 2].type = 0;
15988 }
15989 }
15990 Main.tile[num119, num65 + 2].slope(0);
15991 Main.tile[num119, num65 + 2].halfBrick(halfBrick: false);
15992 }
15993 }
15994 if (Main.tile[num64, num65].type == 26)
15995 {
15996 int num123 = Main.tile[num64, num65].frameX / 18;
15997 int num124 = 0;
15998 int num125 = num64;
15999 int num126 = num65 - Main.tile[num64, num65].frameY / 18;
16000 while (num123 >= 3)
16001 {
16002 num124++;
16003 num123 -= 3;
16004 }
16005 num125 -= num123;
16006 num124 = (drunkWorldGen ? ((Main.tile[num64, num65].wall == 83) ? 1 : 0) : (crimson ? 1 : 0));
16007 for (int num127 = 0; num127 < 3; num127++)
16008 {
16009 for (int num128 = 0; num128 < 2; num128++)
16010 {
16011 int num129 = num125 + num127;
16012 int num130 = num126 + num128;
16013 Main.tile[num129, num130].active(active: true);
16014 Main.tile[num129, num130].slope(0);
16015 Main.tile[num129, num130].halfBrick(halfBrick: false);
16016 Main.tile[num129, num130].type = 26;
16017 Main.tile[num129, num130].frameX = (short)(num127 * 18 + 54 * num124);
16018 Main.tile[num129, num130].frameY = (short)(num128 * 18);
16019 }
16020 if (!Main.tile[num125 + num127, num126 + 2].active() || !Main.tileSolid[Main.tile[num125 + num127, num126 + 2].type] || Main.tileSolidTop[Main.tile[num125 + num127, num126 + 2].type])
16021 {
16022 Main.tile[num125 + num127, num126 + 2].active(active: true);
16023 if (!TileID.Sets.Platforms[Main.tile[num125 + num127, num126 + 2].type])
16024 {
16025 if (Main.tile[num125 + num127, num126 + 2].type == 484)
16026 {
16027 Main.tile[num125 + num127, num126 + 2].type = 397;
16028 }
16029 else if (TileID.Sets.Boulders[Main.tile[num125 + num127, num126 + 2].type] || !Main.tileSolid[Main.tile[num125 + num127, num126 + 2].type] || Main.tileSolidTop[Main.tile[num125 + num127, num126 + 2].type])
16030 {
16031 Main.tile[num125 + num127, num126 + 2].type = 0;
16032 }
16033 }
16034 }
16035 Main.tile[num125 + num127, num126 + 2].slope(0);
16036 Main.tile[num125 + num127, num126 + 2].halfBrick(halfBrick: false);
16037 if (Main.tile[num125 + num127, num126 + 3].type == 28 && Main.tile[num125 + num127, num126 + 3].frameY % 36 >= 18)
16038 {
16039 Main.tile[num125 + num127, num126 + 3].type = 0;
16040 Main.tile[num125 + num127, num126 + 3].active(active: false);
16041 }
16042 }
16043 for (int num131 = 0; num131 < 3; num131++)
16044 {
16045 if ((Main.tile[num125 - 1, num126 + num131].type == 28 || Main.tile[num125 - 1, num126 + num131].type == 12 || Main.tile[num125 - 1, num126 + num131].type == 639) && Main.tile[num125 - 1, num126 + num131].frameX % 36 < 18)
16046 {
16047 Main.tile[num125 - 1, num126 + num131].type = 0;
16048 Main.tile[num125 - 1, num126 + num131].active(active: false);
16049 }
16050 if ((Main.tile[num125 + 3, num126 + num131].type == 28 || Main.tile[num125 + 3, num126 + num131].type == 12 || Main.tile[num125 - 1, num126 + num131].type == 639) && Main.tile[num125 + 3, num126 + num131].frameX % 36 >= 18)
16051 {
16052 Main.tile[num125 + 3, num126 + num131].type = 0;
16053 Main.tile[num125 + 3, num126 + num131].active(active: false);
16054 }
16055 }
16056 }
16057 if (Main.tile[num64, num65].type == 237 && Main.tile[num64, num65 + 1].type == 232)
16058 {
16059 Main.tile[num64, num65 + 1].type = 226;
16060 }
16061 if (Main.tile[num64, num65].wall == 87)
16062 {
16063 Main.tile[num64, num65].liquid = 0;
16064 }
16065 }
16066 }
16067 });
16068 AddGenerationPass("Lihzahrd Altars", delegate(GenerationProgress progress, GameConfiguration passConfig)
16069 {
16070 progress.Set(1.0);
16071 for (int num58 = 0; num58 < 3; num58++)
16072 {
16073 for (int num59 = 0; num59 < 2; num59++)
16074 {
16075 int num60 = GenVars.lAltarX + num58;
16076 int num61 = GenVars.lAltarY + num59;
16077 Main.tile[num60, num61].active(active: true);
16078 Main.tile[num60, num61].type = 237;
16079 Main.tile[num60, num61].frameX = (short)(num58 * 18);
16080 Main.tile[num60, num61].frameY = (short)(num59 * 18);
16081 }
16082 Main.tile[GenVars.lAltarX + num58, GenVars.lAltarY + 2].active(active: true);
16083 Main.tile[GenVars.lAltarX + num58, GenVars.lAltarY + 2].slope(0);
16084 Main.tile[GenVars.lAltarX + num58, GenVars.lAltarY + 2].halfBrick(halfBrick: false);
16085 Main.tile[GenVars.lAltarX + num58, GenVars.lAltarY + 2].type = 226;
16086 }
16087 for (int num62 = 0; num62 < 3; num62++)
16088 {
16089 for (int num63 = 0; num63 < 2; num63++)
16090 {
16091 int i2 = GenVars.lAltarX + num62;
16092 int j2 = GenVars.lAltarY + num63;
16093 SquareTileFrame(i2, j2);
16094 }
16095 }
16096 });
16097 AddGenerationPass("Micro Biomes", delegate(GenerationProgress progress, GameConfiguration passConfig)
16098 {
16099 progress.Message = Lang.gen[76].Value;
16100 _ = (double)(Main.maxTilesX * Main.maxTilesY) / 5040000.0;
16101 double num36 = 10.0;
16102 if (getGoodWorldGen || noTrapsWorldGen)
16103 {
16104 num36 *= 3.0;
16105 }
16106 DeadMansChestBiome deadMansChestBiome = GenVars.configuration.CreateBiome<DeadMansChestBiome>();
16107 List<int> possibleChestsToTrapify = deadMansChestBiome.GetPossibleChestsToTrapify(GenVars.structures);
16108 int random = passConfig.Get<WorldGenRange>("DeadManChests").GetRandom(genRand);
16109 int num37 = 0;
16110 int num38 = 3000;
16111 while (num37 < random && possibleChestsToTrapify.Count > 0)
16112 {
16113 num38--;
16114 if (num38 <= 0)
16115 {
16116 break;
16117 }
16118 int num39 = possibleChestsToTrapify[genRand.Next(possibleChestsToTrapify.Count)];
16119 Point origin = new Point(Main.chest[num39].x, Main.chest[num39].y);
16120 deadMansChestBiome.Place(origin, GenVars.structures);
16121 num37++;
16122 possibleChestsToTrapify.Remove(num39);
16123 }
16124 progress.Set(1.0 / num36);
16125 if (!notTheBees || remixWorldGen)
16126 {
16127 ThinIceBiome thinIceBiome = GenVars.configuration.CreateBiome<ThinIceBiome>();
16128 int random2 = passConfig.Get<WorldGenRange>("ThinIcePatchCount").GetRandom(genRand);
16129 int num40 = 0;
16130 int num41 = 1000;
16131 int num42 = 0;
16132 while (num42 < random2)
16133 {
16134 if (thinIceBiome.Place(RandomWorldPoint((int)Main.worldSurface + 20, 50, 200, 50), GenVars.structures))
16135 {
16136 num42++;
16137 num40 = 0;
16138 }
16139 else
16140 {
16141 num40++;
16142 if (num40 > num41)
16143 {
16144 num42++;
16145 num40 = 0;
16146 }
16147 }
16148 }
16149 }
16150 progress.Set(0.1);
16151 progress.Set(2.0 / num36);
16152 EnchantedSwordBiome enchantedSwordBiome = GenVars.configuration.CreateBiome<EnchantedSwordBiome>();
16153 int num43 = passConfig.Get<WorldGenRange>("SwordShrineAttempts").GetRandom(genRand);
16154 double num44 = passConfig.Get<double>("SwordShrinePlacementChance");
16155 if (tenthAnniversaryWorldGen)
16156 {
16157 num43 *= 2;
16158 num44 /= 2.0;
16159 }
16160 Point origin2 = default(Point);
16161 for (int num45 = 0; num45 < num43; num45++)
16162 {
16163 if ((num45 == 0 && tenthAnniversaryWorldGen) || !(genRand.NextDouble() > num44))
16164 {
16165 int num46 = 0;
16166 while (num46++ <= Main.maxTilesX)
16167 {
16168 origin2.Y = (int)GenVars.worldSurface + genRand.Next(50, 100);
16169 if (genRand.Next(2) == 0)
16170 {
16171 origin2.X = genRand.Next(50, (int)((double)Main.maxTilesX * 0.3));
16172 }
16173 else
16174 {
16175 origin2.X = genRand.Next((int)((double)Main.maxTilesX * 0.7), Main.maxTilesX - 50);
16176 }
16177 if (enchantedSwordBiome.Place(origin2, GenVars.structures))
16178 {
16179 break;
16180 }
16181 }
16182 }
16183 }
16184 progress.Set(0.2);
16185 progress.Set(3.0 / num36);
16186 if (!notTheBees || remixWorldGen)
16187 {
16188 CampsiteBiome campsiteBiome = GenVars.configuration.CreateBiome<CampsiteBiome>();
16189 int random3 = passConfig.Get<WorldGenRange>("CampsiteCount").GetRandom(genRand);
16190 num38 = 1000;
16191 int num47 = 0;
16192 while (num47 < random3)
16193 {
16194 num38--;
16195 if (num38 <= 0)
16196 {
16197 break;
16198 }
16199 if (campsiteBiome.Place(RandomWorldPoint((int)Main.worldSurface, beachDistance, 200, beachDistance), GenVars.structures))
16200 {
16201 num47++;
16202 }
16203 }
16204 }
16205 progress.Set(4.0 / num36);
16206 if (!notTheBees || remixWorldGen)
16207 {
16208 MiningExplosivesBiome miningExplosivesBiome = GenVars.configuration.CreateBiome<MiningExplosivesBiome>();
16209 int num48 = passConfig.Get<WorldGenRange>("ExplosiveTrapCount").GetRandom(genRand);
16210 if ((getGoodWorldGen || noTrapsWorldGen) && !notTheBees)
16211 {
16212 num48 = (int)((double)num48 * 1.5);
16213 }
16214 num38 = 3000;
16215 int num49 = 0;
16216 while (num49 < num48)
16217 {
16218 num38--;
16219 if (num38 <= 0)
16220 {
16221 break;
16222 }
16223 if (remixWorldGen)
16224 {
16225 if (miningExplosivesBiome.Place(RandomWorldPoint((int)Main.worldSurface, beachDistance, (int)GenVars.rockLayer, beachDistance), GenVars.structures))
16226 {
16227 num49++;
16228 }
16229 }
16230 else if (miningExplosivesBiome.Place(RandomWorldPoint((int)GenVars.rockLayer, beachDistance, 200, beachDistance), GenVars.structures))
16231 {
16232 num49++;
16233 }
16234 }
16235 }
16236 progress.Set(0.3);
16237 progress.Set(5.0 / num36);
16238 MahoganyTreeBiome mahoganyTreeBiome = GenVars.configuration.CreateBiome<MahoganyTreeBiome>();
16239 int random4 = passConfig.Get<WorldGenRange>("LivingTreeCount").GetRandom(genRand);
16240 int num50 = 0;
16241 int num51 = 0;
16242 while (num50 < random4 && num51 < 20000)
16243 {
16244 if (mahoganyTreeBiome.Place(RandomWorldPoint((int)Main.worldSurface + 50, 50, 500, 50), GenVars.structures))
16245 {
16246 num50++;
16247 }
16248 num51++;
16249 }
16250 progress.Set(0.4);
16251 progress.Set(6.0 / num36);
16252 progress.Set(7.0 / num36);
16253 TrackGenerator trackGenerator = new TrackGenerator();
16254 int random5 = passConfig.Get<WorldGenRange>("LongTrackCount").GetRandom(genRand);
16255 WorldGenRange worldGenRange = passConfig.Get<WorldGenRange>("LongTrackLength");
16256 int maxTilesX = Main.maxTilesX;
16257 int num52 = 0;
16258 int num53 = 0;
16259 while (num53 < random5)
16260 {
16261 if (trackGenerator.Place(RandomWorldPoint((int)Main.worldSurface, 10, 200, 10), worldGenRange.ScaledMinimum, worldGenRange.ScaledMaximum))
16262 {
16263 num53++;
16264 num52 = 0;
16265 }
16266 else
16267 {
16268 num52++;
16269 if (num52 > maxTilesX)
16270 {
16271 num53++;
16272 num52 = 0;
16273 }
16274 }
16275 }
16276 progress.Set(8.0 / num36);
16277 random5 = passConfig.Get<WorldGenRange>("StandardTrackCount").GetRandom(genRand);
16278 worldGenRange = passConfig.Get<WorldGenRange>("StandardTrackLength");
16279 num52 = 0;
16280 int num54 = 0;
16281 while (num54 < random5)
16282 {
16283 if (trackGenerator.Place(RandomWorldPoint((int)Main.worldSurface, 10, 200, 10), worldGenRange.ScaledMinimum, worldGenRange.ScaledMaximum))
16284 {
16285 num54++;
16286 num52 = 0;
16287 }
16288 else
16289 {
16290 num52++;
16291 if (num52 > maxTilesX)
16292 {
16293 num54++;
16294 num52 = 0;
16295 }
16296 }
16297 }
16298 progress.Set(9.0 / num36);
16299 if (!notTheBees)
16300 {
16301 double num55 = (double)Main.maxTilesX * 0.02;
16302 if (noTrapsWorldGen)
16303 {
16304 num36 *= 5.0;
16305 }
16306 else if (getGoodWorldGen)
16307 {
16308 num36 *= 2.0;
16309 }
16310 for (int num56 = 0; (double)num56 < num55; num56++)
16311 {
16312 for (int num57 = 0; num57 < 10150; num57++)
16313 {
16314 int x2 = genRand.Next(200, Main.maxTilesX - 200);
16315 int y2 = genRand.Next(GenVars.lavaLine - 100, Main.maxTilesY - 210);
16316 if (placeLavaTrap(x2, y2))
16317 {
16318 break;
16319 }
16320 }
16321 }
16322 }
16323 progress.Set(1.0);
16324 });
16325 AddGenerationPass("Water Plants", delegate(GenerationProgress progress, GameConfiguration passConfig)
16326 {
16327 progress.Message = Lang.gen[88].Value;
16328 int num28 = (int)Main.worldSurface;
16329 if (remixWorldGen)
16330 {
16331 num28 = Main.maxTilesY - 200;
16332 }
16333 for (int num29 = 20; num29 < Main.maxTilesX - 20; num29++)
16334 {
16335 progress.Set((double)num29 / (double)Main.maxTilesX);
16336 for (int num30 = 1; num30 < num28; num30++)
16337 {
16338 if (genRand.Next(5) == 0 && Main.tile[num29, num30].liquid > 0)
16339 {
16340 if (!Main.tile[num29, num30].active())
16341 {
16342 if (genRand.Next(2) == 0)
16343 {
16344 PlaceLilyPad(num29, num30);
16345 }
16346 else
16347 {
16348 Point point = PlaceCatTail(num29, num30);
16349 if (InWorld(point.X, point.Y))
16350 {
16351 int num31 = genRand.Next(14);
16352 for (int num32 = 0; num32 < num31; num32++)
16353 {
16354 GrowCatTail(point.X, point.Y);
16355 }
16356 SquareTileFrame(point.X, point.Y);
16357 }
16358 }
16359 }
16360 if ((!Main.tile[num29, num30].active() || Main.tile[num29, num30].type == 61 || Main.tile[num29, num30].type == 74) && PlaceBamboo(num29, num30))
16361 {
16362 int num33 = genRand.Next(10, 20);
16363 for (int num34 = 0; num34 < num33 && PlaceBamboo(num29, num30 - num34); num34++)
16364 {
16365 }
16366 }
16367 }
16368 }
16369 int num35 = Main.UnderworldLayer;
16370 while ((double)num35 > Main.worldSurface)
16371 {
16372 if (Main.tile[num29, num35].type == 53 && genRand.Next(3) != 0)
16373 {
16374 GrowCheckSeaweed(num29, num35);
16375 }
16376 else if (Main.tile[num29, num35].type == 549)
16377 {
16378 GrowCheckSeaweed(num29, num35);
16379 }
16380 num35--;
16381 }
16382 }
16383 });
16384 AddGenerationPass("Stalac", delegate(GenerationProgress progress, GameConfiguration passConfig)
16385 {
16386 progress.Set(1.0);
16387 for (int num24 = 20; num24 < Main.maxTilesX - 20; num24++)
16388 {
16389 for (int num25 = (int)Main.worldSurface; num25 < Main.maxTilesY - 20; num25++)
16390 {
16391 if ((Main.tenthAnniversaryWorld || drunkWorldGen || genRand.Next(5) == 0) && Main.tile[num24, num25 - 1].liquid == 0)
16392 {
16393 int num26 = genRand.Next(7);
16394 int treeTileType = 0;
16395 switch (num26)
16396 {
16397 case 0:
16398 treeTileType = 583;
16399 break;
16400 case 1:
16401 treeTileType = 584;
16402 break;
16403 case 2:
16404 treeTileType = 585;
16405 break;
16406 case 3:
16407 treeTileType = 586;
16408 break;
16409 case 4:
16410 treeTileType = 587;
16411 break;
16412 case 5:
16413 treeTileType = 588;
16414 break;
16415 case 6:
16416 treeTileType = 589;
16417 break;
16418 }
16419 TryGrowingTreeByType(treeTileType, num24, num25);
16420 }
16421 if (!oceanDepths(num24, num25) && !Main.tile[num24, num25].active() && genRand.Next(5) == 0)
16422 {
16423 if ((Main.tile[num24, num25 - 1].type == 1 || Main.tile[num24, num25 - 1].type == 147 || Main.tile[num24, num25 - 1].type == 161 || Main.tile[num24, num25 - 1].type == 25 || Main.tile[num24, num25 - 1].type == 203 || Main.tileStone[Main.tile[num24, num25 - 1].type] || Main.tileMoss[Main.tile[num24, num25 - 1].type]) && !Main.tile[num24, num25].active() && !Main.tile[num24, num25 + 1].active())
16424 {
16425 Main.tile[num24, num25 - 1].slope(0);
16426 }
16427 if ((Main.tile[num24, num25 + 1].type == 1 || Main.tile[num24, num25 + 1].type == 147 || Main.tile[num24, num25 + 1].type == 161 || Main.tile[num24, num25 + 1].type == 25 || Main.tile[num24, num25 + 1].type == 203 || Main.tileStone[Main.tile[num24, num25 + 1].type] || Main.tileMoss[Main.tile[num24, num25 + 1].type]) && !Main.tile[num24, num25].active() && !Main.tile[num24, num25 - 1].active())
16428 {
16429 Main.tile[num24, num25 + 1].slope(0);
16430 }
16431 PlaceTight(num24, num25);
16432 }
16433 }
16434 for (int num27 = 5; num27 < (int)Main.worldSurface; num27++)
16435 {
16436 if ((Main.tile[num24, num27 - 1].type == 147 || Main.tile[num24, num27 - 1].type == 161) && genRand.Next(5) == 0)
16437 {
16438 if (!Main.tile[num24, num27].active() && !Main.tile[num24, num27 + 1].active())
16439 {
16440 Main.tile[num24, num27 - 1].slope(0);
16441 }
16442 PlaceTight(num24, num27);
16443 }
16444 if ((Main.tile[num24, num27 - 1].type == 25 || Main.tile[num24, num27 - 1].type == 203) && genRand.Next(5) == 0)
16445 {
16446 if (!Main.tile[num24, num27].active() && !Main.tile[num24, num27 + 1].active())
16447 {
16448 Main.tile[num24, num27 - 1].slope(0);
16449 }
16450 PlaceTight(num24, num27);
16451 }
16452 if ((Main.tile[num24, num27 + 1].type == 25 || Main.tile[num24, num27 + 1].type == 203) && genRand.Next(5) == 0)
16453 {
16454 if (!Main.tile[num24, num27].active() && !Main.tile[num24, num27 - 1].active())
16455 {
16456 Main.tile[num24, num27 + 1].slope(0);
16457 }
16458 PlaceTight(num24, num27);
16459 }
16460 }
16461 }
16462 });
16463 AddGenerationPass("Remove Broken Traps", delegate(GenerationProgress progress, GameConfiguration passConfig)
16464 {
16465 if (!noTrapsWorldGen || tenthAnniversaryWorldGen || notTheBees)
16466 {
16467 progress.Message = Lang.gen[82].Value;
16468 List<Point> list = new List<Point>();
16469 int num21 = 50;
16470 for (int num22 = num21; num22 < Main.maxTilesX - num21; num22++)
16471 {
16472 double value = (double)(num22 - num21) / (double)(Main.maxTilesX - num21 * 2);
16473 progress.Set(value);
16474 for (int num23 = 50; num23 < Main.maxTilesY - 50; num23++)
16475 {
16476 if (Main.tile[num22, num23].wire() && !list.Contains(new Point(num22, num23)))
16477 {
16478 ClearBrokenTraps(new Point(num22, num23), list);
16479 }
16480 }
16481 }
16482 }
16483 });
16484 AddGenerationPass("Final Cleanup", delegate(GenerationProgress progress, GameConfiguration passConfig)
16485 {
16486 Main.tileSolid[484] = false;
16487 FillWallHolesInArea(new Rectangle(0, 0, Main.maxTilesX, (int)Main.worldSurface));
16488 progress.Message = Lang.gen[86].Value;
16489 for (int i = 0; i < Main.maxTilesX; i++)
16490 {
16491 progress.Set((double)i / (double)Main.maxTilesX);
16492 for (int j = 0; j < Main.maxTilesY; j++)
16493 {
16494 if (Main.tile[i, j].active() && !SolidTile(i, j + 1) && (Main.tile[i, j].type == 53 || Main.tile[i, j].type == 112 || Main.tile[i, j].type == 234 || Main.tile[i, j].type == 224 || Main.tile[i, j].type == 123))
16495 {
16496 if ((double)j < Main.worldSurface + 10.0 && !Main.tile[i, j + 1].active() && Main.tile[i, j + 1].wall != 191 && !oceanDepths(i, j))
16497 {
16498 int num = 10;
16499 int num2 = j + 1;
16500 for (int k = num2; k < num2 + 10; k++)
16501 {
16502 if (Main.tile[i, k].active() && Main.tile[i, k].type == 314)
16503 {
16504 num = 0;
16505 break;
16506 }
16507 }
16508 while (!Main.tile[i, num2].active() && num > 0 && num2 < Main.maxTilesY - 50)
16509 {
16510 Main.tile[i, num2 - 1].slope(0);
16511 Main.tile[i, num2 - 1].halfBrick(halfBrick: false);
16512 Main.tile[i, num2].active(active: true);
16513 Main.tile[i, num2].type = Main.tile[i, j].type;
16514 Main.tile[i, num2].slope(0);
16515 Main.tile[i, num2].halfBrick(halfBrick: false);
16516 num2++;
16517 num--;
16518 }
16519 if (num == 0 && !Main.tile[i, num2].active())
16520 {
16521 switch (Main.tile[i, j].type)
16522 {
16523 case 53:
16524 Main.tile[i, num2].type = 397;
16525 Main.tile[i, num2].active(active: true);
16526 break;
16527 case 112:
16528 Main.tile[i, num2].type = 398;
16529 Main.tile[i, num2].active(active: true);
16530 break;
16531 case 234:
16532 Main.tile[i, num2].type = 399;
16533 Main.tile[i, num2].active(active: true);
16534 break;
16535 case 224:
16536 Main.tile[i, num2].type = 147;
16537 Main.tile[i, num2].active(active: true);
16538 break;
16539 case 123:
16540 Main.tile[i, num2].type = 1;
16541 Main.tile[i, num2].active(active: true);
16542 break;
16543 }
16544 }
16545 else if (Main.tile[i, num2].active() && Main.tileSolid[Main.tile[i, num2].type] && !Main.tileSolidTop[Main.tile[i, num2].type])
16546 {
16547 Main.tile[i, num2].slope(0);
16548 Main.tile[i, num2].halfBrick(halfBrick: false);
16549 }
16550 }
16551 else if (Main.tileSolid[Main.tile[i, j + 1].type] && !Main.tileSolidTop[Main.tile[i, j + 1].type] && (Main.tile[i, j + 1].topSlope() || Main.tile[i, j + 1].halfBrick()))
16552 {
16553 Main.tile[i, j + 1].slope(0);
16554 Main.tile[i, j + 1].halfBrick(halfBrick: false);
16555 }
16556 else
16557 {
16558 switch (Main.tile[i, j].type)
16559 {
16560 case 53:
16561 Main.tile[i, j].type = 397;
16562 break;
16563 case 112:
16564 Main.tile[i, j].type = 398;
16565 break;
16566 case 234:
16567 Main.tile[i, j].type = 399;
16568 break;
16569 case 224:
16570 Main.tile[i, j].type = 147;
16571 break;
16572 case 123:
16573 Main.tile[i, j].type = 1;
16574 break;
16575 }
16576 }
16577 if (Main.tile[i, j - 1].type == 323)
16578 {
16579 TileFrame(i, j - 1);
16580 }
16581 }
16582 if ((Main.tile[i, j].wall == 187 || Main.tile[i, j].wall == 216) && Main.tile[i, j].liquid > 0 && !remixWorldGen)
16583 {
16584 Main.tile[i, j].liquid = byte.MaxValue;
16585 Main.tile[i, j].lava(lava: true);
16586 }
16587 if (Main.tile[i, j].type == 485 || Main.tile[i, j].type == 187 || Main.tile[i, j].type == 165)
16588 {
16589 TileFrame(i, j);
16590 }
16591 if (Main.tile[i, j].type == 28)
16592 {
16593 TileFrame(i, j);
16594 }
16595 if (Main.tile[i, j].type == 10 || Main.tile[i, j].type == 11)
16596 {
16597 TileFrame(i, j);
16598 }
16599 if (Main.tile[i, j].type == 26)
16600 {
16601 TileFrame(i, j);
16602 }
16603 if (TileID.Sets.IsATreeTrunk[Main.tile[i, j].type] || Main.tile[i, j].type == 323)
16604 {
16605 TileFrame(i, j);
16606 }
16607 if (Main.tile[i, j].type == 137)
16608 {
16609 Main.tile[i, j].slope(0);
16610 Main.tile[i, j].halfBrick(halfBrick: false);
16611 }
16612 if (Main.tile[i, j].active() && TileID.Sets.Boulders[Main.tile[i, j].type])
16613 {
16614 int num3 = Main.tile[i, j].frameX / 18;
16615 int num4 = i;
16616 num4 -= num3;
16617 int num5 = Main.tile[i, j].frameY / 18;
16618 int num6 = j;
16619 num6 -= num5;
16620 bool flag = false;
16621 for (int l = 0; l < 2; l++)
16622 {
16623 Tile tile = Main.tile[num4 + l, num6 - 1];
16624 if (tile != null && tile.active() && tile.type == 26)
16625 {
16626 flag = true;
16627 break;
16628 }
16629 for (int m = 0; m < 2; m++)
16630 {
16631 int num7 = num4 + l;
16632 int num8 = num6 + m;
16633 Main.tile[num7, num8].active(active: true);
16634 Main.tile[num7, num8].slope(0);
16635 Main.tile[num7, num8].halfBrick(halfBrick: false);
16636 Main.tile[num7, num8].type = Main.tile[i, j].type;
16637 Main.tile[num7, num8].frameX = (short)(l * 18);
16638 Main.tile[num7, num8].frameY = (short)(m * 18);
16639 }
16640 }
16641 if (flag)
16642 {
16643 ushort type = 0;
16644 if (Main.tile[i, j].type == 484)
16645 {
16646 type = 397;
16647 }
16648 for (int n = 0; n < 2; n++)
16649 {
16650 for (int num9 = 0; num9 < 2; num9++)
16651 {
16652 int num10 = num4 + n;
16653 int num11 = num6 + num9;
16654 Main.tile[num10, num11].active(active: true);
16655 Main.tile[num10, num11].slope(0);
16656 Main.tile[num10, num11].halfBrick(halfBrick: false);
16657 Main.tile[num10, num11].type = type;
16658 Main.tile[num10, num11].frameX = 0;
16659 Main.tile[num10, num11].frameY = 0;
16660 }
16661 }
16662 }
16663 }
16664 if (Main.tile[i, j].type == 323 && Main.tile[i, j].liquid > 0)
16665 {
16666 KillTile(i, j);
16667 }
16668 if (Main.wallDungeon[Main.tile[i, j].wall])
16669 {
16670 Main.tile[i, j].lava(lava: false);
16671 if (Main.tile[i, j].active() && Main.tile[i, j].type == 56)
16672 {
16673 KillTile(i, j);
16674 Main.tile[i, j].lava(lava: false);
16675 Main.tile[i, j].liquid = byte.MaxValue;
16676 }
16677 }
16678 if (Main.tile[i, j].active() && Main.tile[i, j].type == 314)
16679 {
16680 int num12 = 15;
16681 int num13 = 1;
16682 int num14 = j;
16683 while (j - num14 < num12)
16684 {
16685 Main.tile[i, num14].liquid = 0;
16686 num14--;
16687 }
16688 for (num14 = j; num14 - j < num13; num14++)
16689 {
16690 Main.tile[i, num14].liquid = 0;
16691 }
16692 }
16693 if (Main.tile[i, j].active() && Main.tile[i, j].type == 332 && !Main.tile[i, j + 1].active())
16694 {
16695 Main.tile[i, j + 1].ClearEverything();
16696 Main.tile[i, j + 1].active(active: true);
16697 Main.tile[i, j + 1].type = 332;
16698 }
16699 if (i > beachDistance && i < Main.maxTilesX - beachDistance && (double)j < Main.worldSurface && Main.tile[i, j].liquid > 0 && Main.tile[i, j].liquid < byte.MaxValue && Main.tile[i - 1, j].liquid < byte.MaxValue && Main.tile[i + 1, j].liquid < byte.MaxValue && Main.tile[i, j + 1].liquid < byte.MaxValue && !TileID.Sets.Clouds[Main.tile[i - 1, j].type] && !TileID.Sets.Clouds[Main.tile[i + 1, j].type] && !TileID.Sets.Clouds[Main.tile[i, j + 1].type])
16700 {
16701 Main.tile[i, j].liquid = 0;
16702 }
16703 }
16704 }
16705 int num15 = 0;
16706 int num16 = 3;
16707 num16 = GetWorldSize() switch
16708 {
16709 1 => 6,
16710 2 => 9,
16711 _ => 3,
16712 };
16713 if (tenthAnniversaryWorldGen)
16714 {
16715 num16 *= 5;
16716 }
16717 int num17 = 50;
16718 int minValue = num17;
16719 int minValue2 = num17;
16720 int maxValue = Main.maxTilesX - num17;
16721 int maxValue2 = Main.maxTilesY - 200;
16722 int num18 = 3000;
16723 while (num15 < num16)
16724 {
16725 num18--;
16726 if (num18 <= 0)
16727 {
16728 break;
16729 }
16730 int num19 = genRand.Next(minValue, maxValue);
16731 int num20 = genRand.Next(minValue2, maxValue2);
16732 Tile tile2 = Main.tile[num19, num20];
16733 if (tile2.active() && tile2.type >= 0 && tile2.type < TileID.Count)
16734 {
16735 bool flag2 = TileID.Sets.Dirt[tile2.type];
16736 if (notTheBees)
16737 {
16738 flag2 = flag2 || TileID.Sets.Mud[tile2.type];
16739 }
16740 if (flag2)
16741 {
16742 num15++;
16743 tile2.ClearTile();
16744 tile2.active(active: true);
16745 tile2.type = 668;
16746 }
16747 }
16748 }
16749 if (noTrapsWorldGen)
16750 {
16751 FinishNoTraps();
16752 }
16753 if (Main.tenthAnniversaryWorld)
16754 {
16755 FinishTenthAnniversaryWorld();
16756 }
16757 if (drunkWorldGen)
16758 {
16759 FinishDrunkGen();
16760 }
16761 if (notTheBees)
16762 {
16763 NotTheBees();
16764 FinishNotTheBees();
16765 }
16766 if (getGoodWorldGen)
16767 {
16768 FinishGetGoodWorld();
16769 }
16770 if (remixWorldGen)
16771 {
16772 FinishRemixWorld();
16773 }
16774 ShimmerCleanUp();
16775 notTheBees = false;
16776 getGoodWorldGen = false;
16777 noTileActions = false;
16778 Main.tileSolid[659] = true;
16779 Main.tileSolid[GenVars.crackedType] = true;
16780 Main.tileSolid[484] = true;
16781 gen = false;
16782 Main.AnglerQuestSwap();
16783 skipFramingDuringGen = false;
16784 progress.Message = Lang.gen[87].Value;
16785 });
16786 _generator.GenerateWorld(customProgressObject);
16787 ConsumePostGenActions(GenVars.structures);
16788 Main.WorldFileMetadata = FileMetadata.FromCurrentSettings(FileType.World);
16789 Main.NotifyOfEvent(GameNotificationType.WorldGen);
16790 drunkWorldGenText = false;
16791 }
System.Collections.Generic.Dictionary.Remove
bool ICollection< KeyValuePair< TKey, TValue > >. Remove(KeyValuePair< TKey, TValue > keyValuePair)
Definition Dictionary.cs:893
System.Collections.Generic.Dictionary.Contains
bool ICollection< KeyValuePair< TKey, TValue > >. Contains(KeyValuePair< TKey, TValue > keyValuePair)
Definition Dictionary.cs:883
System.Collections.Generic.Dictionary.Add
void Add(TKey key, TValue value)
Definition Dictionary.cs:873
System.Console.WriteLine
static void WriteLine()
Definition Console.cs:733
System.Math.Cos
static double Cos(double d)
System.Math.Min
static byte Min(byte val1, byte val2)
Definition Math.cs:912
System.Math.Abs
static double Abs(double value)
System.Math.Sin
static double Sin(double a)
System.Threading.Thread.Sleep
static void Sleep(int millisecondsTimeout)
Definition Thread.cs:658
Terraria.DataStructures.EntitySource_WorldGen
Definition EntitySource_WorldGen.cs:4
Terraria.GameContent.Biomes.GraniteBiome.CanPlace
static bool CanPlace(Point origin, StructureMap structures)
Definition GraniteBiome.cs:64
Terraria.ID.TileID.Sets.Crimson
static bool[] Crimson
Definition TileID.cs:249
Terraria.ID.TileID.Sets.Mud
static bool[] Mud
Definition TileID.cs:199
Terraria.ID.TileID.Sets.Boulders
static bool[] Boulders
Definition TileID.cs:123
Terraria.ID.TileID.Sets.Falling
static bool[] Falling
Definition TileID.cs:289
Terraria.ID.TileID.Sets.Dirt
static bool[] Dirt
Definition TileID.cs:197
Terraria.ID.TileID.Sets.SlowlyDiesInWater
static bool[] SlowlyDiesInWater
Definition TileID.cs:169
Terraria.ID.TileID.Sets.BasicChest
static bool[] BasicChest
Definition TileID.cs:223
Terraria.ID.TileID.Sets.Clouds
static bool[] Clouds
Definition TileID.cs:125
Terraria.ID.TileID.Sets.Ore
static bool[] Ore
Definition TileID.cs:295
Terraria.ID.TileID.Sets.CanBeClearedDuringGeneration
static bool[] CanBeClearedDuringGeneration
Definition TileID.cs:229
Terraria.ID.TileID.Sets.Platforms
static bool[] Platforms
Definition TileID.cs:163
Terraria.ID.TileID.Sets.Corrupt
static bool[] Corrupt
Definition TileID.cs:235
Terraria.ID.TileID.Sets.IsATreeTrunk
static bool[] IsATreeTrunk
Definition TileID.cs:91
Terraria.ID.TileID.Count
static readonly ushort Count
Definition TileID.cs:1698
Terraria.IO.FileMetadata.FromCurrentSettings
static FileMetadata FromCurrentSettings(FileType type)
Definition FileMetadata.cs:35
Terraria.Localization.Language.GetTextValue
static string GetTextValue(string key)
Definition Language.cs:15
Terraria.WorldBuilding.Actions.Chain
static GenAction Chain(params GenAction[] actions)
Definition Actions.cs:470
Terraria.WorldBuilding.GenAction.Output
GenAction Output(ShapeData data)
Definition GenAction.cs:39
Terraria.WorldBuilding.GenVars.beachSandRandomWidthRange
static int beachSandRandomWidthRange
Definition GenVars.cs:70
Terraria.WorldBuilding.GenVars.oasisHeight
static readonly int oasisHeight
Definition GenVars.cs:298
Terraria.WorldBuilding.GenVars.floatingIslandHouseY
static int[] floatingIslandHouseY
Definition GenVars.cs:252
Terraria.WorldBuilding.GenVars.UndergroundDesertHiveLocation
static Rectangle UndergroundDesertHiveLocation
Definition GenVars.cs:112
Terraria.WorldBuilding.GenVars.floatingIslandStyle
static int[] floatingIslandStyle
Definition GenVars.cs:254
Terraria.WorldBuilding.GenVars.beachSandJungleExtraWidth
static int beachSandJungleExtraWidth
Definition GenVars.cs:74
Terraria.WorldBuilding.GenVars.oasisPosition
static Point[] oasisPosition
Definition GenVars.cs:294
Terraria.WorldBuilding.GenVars.maxTunnels
static readonly int maxTunnels
Definition GenVars.cs:262
Terraria.WorldBuilding.GenVars.oceanWaterStartRandomMin
static int oceanWaterStartRandomMin
Definition GenVars.cs:84
Terraria.WorldBuilding.GenVars.worldSurfaceHigh
static double worldSurfaceHigh
Definition GenVars.cs:42
Terraria.WorldBuilding.GenVars.floatingIslandHouseX
static int[] floatingIslandHouseX
Definition GenVars.cs:250
Terraria.WorldBuilding.GenVars.configuration
static WorldGenConfiguration configuration
Definition GenVars.cs:10
Terraria.WorldBuilding.GenVars.oceanCaveTreasure
static Point[] oceanCaveTreasure
Definition GenVars.cs:106
Terraria.WorldBuilding.GenVars.maxLakes
static readonly int maxLakes
Definition GenVars.cs:284
Terraria.WorldBuilding.GenVars.evilBiomeBeachAvoidance
static int evilBiomeBeachAvoidance
Definition GenVars.cs:90
Terraria.WorldBuilding.GenVars.smallHolesBeachAvoidance
static int smallHolesBeachAvoidance
Definition GenVars.cs:96
Terraria.WorldBuilding.GenVars.shimmerPosition
static Vector2D shimmerPosition
Definition GenVars.cs:310
Terraria.WorldBuilding.GenVars.worldSurfaceLow
static double worldSurfaceLow
Definition GenVars.cs:38
Terraria.WorldBuilding.GenVars.oceanWaterForcedJungleLength
static int oceanWaterForcedJungleLength
Definition GenVars.cs:88
Terraria.WorldBuilding.GenVars.mushroomBiomesPosition
static Point[] mushroomBiomesPosition
Definition GenVars.cs:278
Terraria.WorldBuilding.GenVars.surfaceCavesBeachAvoidance2
static int surfaceCavesBeachAvoidance2
Definition GenVars.cs:100
Terraria.WorldBuilding.GenVars.maxMushroomBiomes
static readonly int maxMushroomBiomes
Definition GenVars.cs:274
Terraria.WorldBuilding.GenVars.StatuesWithTraps
static List< int > StatuesWithTraps
Definition GenVars.cs:306
Terraria.WorldBuilding.GenVars.oceanWaterStartRandomMax
static int oceanWaterStartRandomMax
Definition GenVars.cs:86
Terraria.WorldBuilding.GenVars.beachSandDungeonExtraWidth
static int beachSandDungeonExtraWidth
Definition GenVars.cs:72
Terraria.WorldBuilding.GenVars.structures
static StructureMap structures
Definition GenVars.cs:12
Terraria.WorldBuilding.GenVars.statueList
static Point16[] statueList
Definition GenVars.cs:304
Terraria.WorldBuilding.GenVars.evilBiomeAvoidanceMidFixer
static int evilBiomeAvoidanceMidFixer
Definition GenVars.cs:92
Terraria.WorldBuilding.GenVars.maxOrePatch
static readonly int maxOrePatch
Definition GenVars.cs:268
Terraria.WorldBuilding.GenVars.UndergroundDesertLocation
static Rectangle UndergroundDesertLocation
Definition GenVars.cs:110
Terraria.WorldBuilding.GenVars.rockLayerHigh
static double rockLayerHigh
Definition GenVars.cs:48
Terraria.WorldBuilding.WorldGenConfiguration.FromEmbeddedPath
static WorldGenConfiguration FromEmbeddedPath(string path)
Definition WorldGenConfiguration.cs:69
Terraria.WorldBuilding.WorldUtils.Gen
static bool Gen(Point origin, GenShape shape, GenAction action)
Definition WorldUtils.cs:17
Terraria.WorldGen.tempRemixWorldGen
static bool tempRemixWorldGen
Definition WorldGen.cs:1146
Terraria.WorldGen._lastSeed
static int _lastSeed
Definition WorldGen.cs:1016
Terraria.WorldGen.AddGenerationPass
static void AddGenerationPass(string name, WorldGenLegacyMethod method)
Definition WorldGen.cs:6236
Terraria.WorldGen.cactusWaterHeight
static readonly int cactusWaterHeight
Definition WorldGen.cs:1096
Terraria.WorldGen.SmallConsecutivesEliminated
static int SmallConsecutivesEliminated
Definition WorldGen.cs:1144
Terraria.WorldGen.randMoss
static void randMoss(bool justNeon=false)
Definition WorldGen.cs:5870
Terraria.WorldGen.growGrassUnderground
static bool growGrassUnderground
Definition WorldGen.cs:1194
Terraria.WorldGen.WorldGenParam_Evil
static int WorldGenParam_Evil
Definition WorldGen.cs:1092
Terraria.WorldGen.CloudIsland
static void CloudIsland(int i, int j)
Definition WorldGen.cs:68175
Terraria.WorldGen.oceanCave
static void oceanCave(int i, int j)
Definition WorldGen.cs:66402
Terraria.WorldGen.PlaceOasisPlant
static void PlaceOasisPlant(int X, int Y, ushort type=530)
Definition WorldGen.cs:38823
Terraria.WorldGen.FinishTenthAnniversaryWorld
static void FinishTenthAnniversaryWorld()
Definition WorldGen.cs:16853
Terraria.WorldGen.placeTNTBarrel
static bool placeTNTBarrel(int x, int y)
Definition WorldGen.cs:5132
Terraria.WorldGen.remixWorldGen
static bool remixWorldGen
Definition WorldGen.cs:1148
Terraria.WorldGen.gen
static volatile bool gen
Definition WorldGen.cs:972
Terraria.WorldGen.PlantAlch
static void PlantAlch()
Definition WorldGen.cs:36832
Terraria.WorldGen.MakeDungeon
static void MakeDungeon(int x, int y)
Definition WorldGen.cs:26588
Terraria.WorldGen.CountNearBlocksTypes
static int CountNearBlocksTypes(int i, int j, int radius, int cap=0, params int[] tiletypes)
Definition WorldGen.cs:60071
Terraria.WorldGen.RandomRectanglePoint
static Point RandomRectanglePoint(Rectangle rectangle)
Definition WorldGen.cs:18765
Terraria.WorldGen.Place3x2
static void Place3x2(int x, int y, ushort type, int style=0)
Definition WorldGen.cs:43614
Terraria.WorldGen.PlaceSmallPile
static bool PlaceSmallPile(int i, int j, int X, int Y, ushort type=185)
Definition WorldGen.cs:37851
Terraria.WorldGen.placeLavaTrap
static bool placeLavaTrap(int x, int y)
Definition WorldGen.cs:5016
Terraria.WorldGen.NotTheBees
static void NotTheBees()
Definition WorldGen.cs:17328
Terraria.WorldGen.FinishNotTheBees
static void FinishNotTheBees()
Definition WorldGen.cs:17483
Terraria.WorldGen.KillTile
static void KillTile(int i, int j, bool fail=false, bool effectOnly=false, bool noItem=false)
Definition WorldGen.cs:54141
Terraria.WorldGen.PlantCactus
static void PlantCactus(int i, int j)
Definition WorldGen.cs:45781
Terraria.WorldGen.everythingWorldGen
static bool everythingWorldGen
Definition WorldGen.cs:1150
Terraria.WorldGen.FinishDrunkGen
static void FinishDrunkGen()
Definition WorldGen.cs:18064
Terraria.WorldGen.GrowCheckSeaweed
static void GrowCheckSeaweed(int x, int y)
Definition WorldGen.cs:49851
Terraria.WorldGen.GrowPalmTree
static bool GrowPalmTree(int i, int y)
Definition WorldGen.cs:18785
Terraria.WorldGen.MakeWateryIceThing
static void MakeWateryIceThing(int i, int j)
Definition WorldGen.cs:69687
Terraria.WorldGen.cactusWaterWidth
static readonly int cactusWaterWidth
Definition WorldGen.cs:1094
Terraria.WorldGen.TryGrowingTreeByType
static bool TryGrowingTreeByType(int treeTileType, int checkedX, int checkedY)
Definition WorldGen.cs:22170
Terraria.WorldGen.shroomCount
static int shroomCount
Definition WorldGen.cs:1042
Terraria.WorldGen.noTrapsWorldGen
static bool noTrapsWorldGen
Definition WorldGen.cs:1152
Terraria.WorldGen.GrowLivingTree
static bool GrowLivingTree(int i, int j, bool patch=false)
Definition WorldGen.cs:19604
Terraria.WorldGen.shimmerSafetyDistance
static readonly int shimmerSafetyDistance
Definition WorldGen.cs:930
Terraria.WorldGen.PlaceTile
static bool PlaceTile(int i, int j, int Type, bool mute=false, bool forced=false, int plr=-1, int style=0)
Definition WorldGen.cs:50270
Terraria.WorldGen.tenthAnniversaryWorldGen
static bool tenthAnniversaryWorldGen
Definition WorldGen.cs:1160
Terraria.WorldGen.PoundTile
static bool PoundTile(int i, int j)
Definition WorldGen.cs:70910
Terraria.WorldGen.SonOfLakinater
static void SonOfLakinater(int i, int j, double strengthMultiplier=1.0)
Definition WorldGen.cs:69834
Terraria.WorldGen.SmallConsecutivesFound
static int SmallConsecutivesFound
Definition WorldGen.cs:1142
Terraria.WorldGen.placingTraps
static bool placingTraps
Definition WorldGen.cs:1168
Terraria.WorldGen.genRand
static UnifiedRandom genRand
Definition WorldGen.cs:1215
Terraria.WorldGen.RandomizeBackgrounds
static void RandomizeBackgrounds(UnifiedRandom random)
Definition WorldGen.cs:4313
Terraria.WorldGen.TreeTops
static TreeTopsInfo TreeTops
Definition WorldGen.cs:1178
Terraria.WorldGen.PlaceLilyPad
static bool PlaceLilyPad(int x, int j)
Definition WorldGen.cs:50017
Terraria.WorldGen.Caverer
static void Caverer(int X, int Y)
Definition WorldGen.cs:69144
Terraria.WorldGen.CanKillTile
static bool CanKillTile(int i, int j, SpecialKillTileContext context)
Definition WorldGen.cs:52892
Terraria.WorldGen.RandomizeWeather
static void RandomizeWeather()
Definition WorldGen.cs:4140
Terraria.WorldGen.ChasmRunner
static void ChasmRunner(int i, int j, int steps, bool makeOrb=false)
Definition WorldGen.cs:65791
Terraria.WorldGen.crimson
static bool crimson
Definition WorldGen.cs:932
Terraria.WorldGen.PlaceOasis
static bool PlaceOasis(int X, int Y)
Definition WorldGen.cs:6880
Terraria.WorldGen.PlaceCatTail
static Point PlaceCatTail(int x, int j)
Definition WorldGen.cs:49560
Terraria.WorldGen.DesertCloudIsland
static void DesertCloudIsland(int i, int j)
Definition WorldGen.cs:67759
Terraria.WorldGen.GetWorldSize
static int GetWorldSize()
Definition WorldGen.cs:3021
Terraria.WorldGen.lavaCount
static int lavaCount
Definition WorldGen.cs:1034
Terraria.WorldGen.FinishRemixWorld
static void FinishRemixWorld()
Definition WorldGen.cs:18179
Terraria.WorldGen.tempTenthAnniversaryWorldGen
static bool tempTenthAnniversaryWorldGen
Definition WorldGen.cs:1158
Terraria.WorldGen.AddHellHouses
static void AddHellHouses()
Definition WorldGen.cs:23800
Terraria.WorldGen.dontStarveWorldGen
static bool dontStarveWorldGen
Definition WorldGen.cs:1162
Terraria.WorldGen.ShimmerCleanUp
static void ShimmerCleanUp()
Definition WorldGen.cs:26169
Terraria.WorldGen.drunkWorldGenText
static bool drunkWorldGenText
Definition WorldGen.cs:1166
Terraria.WorldGen.Mountinater
static void Mountinater(int i, int j)
Definition WorldGen.cs:69597
Terraria.WorldGen.RollRandomSeaShellStyle
static int RollRandomSeaShellStyle()
Definition WorldGen.cs:36211
Terraria.WorldGen.RandomizeTreeStyle
static void RandomizeTreeStyle()
Definition WorldGen.cs:4440
Terraria.WorldGen.sandCount
static int sandCount
Definition WorldGen.cs:1038
Terraria.WorldGen.oceanDepths
static bool oceanDepths(int x, int y)
Definition WorldGen.cs:7142
Terraria.WorldGen.ConsumePostGenActions
static void ConsumePostGenActions(StructureMap structures)
Definition WorldGen.cs:18757
Terraria.WorldGen.beachDistance
static readonly int beachDistance
Definition WorldGen.cs:928
Terraria.WorldGen.plantDye
static void plantDye(int i, int j, bool exoticPlant=false)
Definition WorldGen.cs:61696
Terraria.WorldGen.AddBuriedChest
static bool AddBuriedChest(Point point, int contain=0, bool notNearOtherChests=false, int Style=-1)
Definition WorldGen.cs:30881
Terraria.WorldGen.FinishNoTraps
static void FinishNoTraps()
Definition WorldGen.cs:17851
Terraria.WorldGen.SetupStatueList
static void SetupStatueList()
Definition WorldGen.cs:1246
Terraria.WorldGen.PlaceJunglePlant
static void PlaceJunglePlant(int X2, int Y2, ushort type, int styleX, int styleY)
Definition WorldGen.cs:39047
Terraria.WorldGen.CaveOpenater
static void CaveOpenater(int i, int j)
Definition WorldGen.cs:70255
Terraria.WorldGen.templePart2
static void templePart2()
Definition WorldGen.cs:25916
Terraria.WorldGen.GrowMoreVines
static bool GrowMoreVines(int x, int y)
Definition WorldGen.cs:36612
Terraria.WorldGen.Convert
static void Convert(int i, int j, int conversionType, int size=4)
Definition WorldGen.cs:46865
Terraria.WorldGen.TileFrame
static void TileFrame(int i, int j, bool resetFrame=false, bool noBreak=false)
Definition WorldGen.cs:71431
Terraria.WorldGen.grassSpread
static int grassSpread
Definition WorldGen.cs:1198
Terraria.WorldGen.noTileActions
static bool noTileActions
Definition WorldGen.cs:966
Terraria.WorldGen.TuneOceanDepth
static double TuneOceanDepth(int count, double depth, bool floridaStyle=false)
Definition WorldGen.cs:18616
Terraria.WorldGen.ShimmerMakeBiome
static bool ShimmerMakeBiome(int X, int Y)
Definition WorldGen.cs:26292
Terraria.WorldGen.neonMossBiome
static void neonMossBiome(int i, int j, int maxY=99999)
Definition WorldGen.cs:5889
Terraria.WorldGen.SlopeTile
static bool SlopeTile(int i, int j, int slope=0, bool noEffects=false)
Definition WorldGen.cs:70878
Terraria.WorldGen.CloudLake
static void CloudLake(int i, int j)
Definition WorldGen.cs:68600
Terraria.WorldGen.GrowSeaOat
static bool GrowSeaOat(int x, int y)
Definition WorldGen.cs:49275
Terraria.WorldGen.SnowCloudIsland
static void SnowCloudIsland(int i, int j)
Definition WorldGen.cs:67343
Terraria.WorldGen.PlaceBamboo
static bool PlaceBamboo(int x, int y)
Definition WorldGen.cs:49324
Terraria.WorldGen.MarblePileWithStatues
static bool MarblePileWithStatues(int X, int Y)
Definition WorldGen.cs:6585
Terraria.WorldGen.ScanTileColumnAndRemoveClumps
static void ScanTileColumnAndRemoveClumps(int x)
Definition WorldGen.cs:6332
Terraria.WorldGen.ShellPile
static bool ShellPile(int X, int Y)
Definition WorldGen.cs:6475
Terraria.WorldGen.GetAdjustedFloorPosition
static Point GetAdjustedFloorPosition(int x, int y)
Definition WorldGen.cs:16793
Terraria.WorldGen.cactusWaterLimit
static readonly int cactusWaterLimit
Definition WorldGen.cs:1098
Terraria.WorldGen._genRand
static UnifiedRandom _genRand
Definition WorldGen.cs:1011
Terraria.WorldGen.RandomizeMoonState
static void RandomizeMoonState(UnifiedRandom random, bool garenteeNewStyle=false)
Definition WorldGen.cs:4152
Terraria.WorldGen.heartCount
static int heartCount
Definition WorldGen.cs:1202
Terraria.WorldGen.PlacePot
static bool PlacePot(int x, int y, ushort type=28, int style=0)
Definition WorldGen.cs:45687
Terraria.WorldGen.RandomizeCaveBackgrounds
static void RandomizeCaveBackgrounds()
Definition WorldGen.cs:4515
Terraria.WorldGen.MatureTheHerbPlants
static void MatureTheHerbPlants()
Definition WorldGen.cs:36679
Terraria.WorldGen.PlantSeaOat
static bool PlantSeaOat(int x, int y)
Definition WorldGen.cs:49237
Terraria.WorldGen.countDirtTiles
static int countDirtTiles(int x, int y)
Definition WorldGen.cs:5770
Terraria.WorldGen.rockCount
static int rockCount
Definition WorldGen.cs:1040
Terraria.WorldGen._generator
static WorldGenerator _generator
Definition WorldGen.cs:1140
Terraria.WorldGen.iceCount
static int iceCount
Definition WorldGen.cs:1036
Terraria.WorldGen.PlaceWall
static void PlaceWall(int i, int j, int type, bool mute=false)
Definition WorldGen.cs:64969
Terraria.WorldGen.GrowGlowTulips
static void GrowGlowTulips()
Definition WorldGen.cs:36648
Terraria.WorldGen.PlaceStatueTrap
static void PlaceStatueTrap(int x, int y)
Definition WorldGen.cs:1287
Terraria.WorldGen.DirtyRockRunner
static void DirtyRockRunner(int i, int j)
Definition WorldGen.cs:67181
Terraria.WorldGen.CrimStart
static void CrimStart(int i, int j)
Definition WorldGen.cs:65288
Terraria.WorldGen.SpreadGrass
static void SpreadGrass(int i, int j, int dirt=0, int grass=2, bool repeat=true, TileColorCache color=default(TileColorCache))
Definition WorldGen.cs:64990
Terraria.WorldGen.ResetGenerator
static void ResetGenerator()
Definition WorldGen.cs:4574
Terraria.WorldGen.drunkWorldGen
static bool drunkWorldGen
Definition WorldGen.cs:1154
Terraria.WorldGen.skipFramingDuringGen
static bool skipFramingDuringGen
Definition WorldGen.cs:1212
Terraria.WorldGen.GetNextJungleChestItem
static int GetNextJungleChestItem()
Definition WorldGen.cs:6298
Terraria.WorldGen.TileRunner
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)
Definition WorldGen.cs:66759
Terraria.WorldGen.maxTileCount
static int maxTileCount
Definition WorldGen.cs:1028
Terraria.WorldGen.GrowUndergroundTree
static void GrowUndergroundTree(int i, int y)
Definition WorldGen.cs:22670
Terraria.WorldGen.Pyramid
static bool Pyramid(int i, int j)
Definition WorldGen.cs:19340
Terraria.WorldGen.InWorld
static bool InWorld(int x, int y, int fluff=0)
Definition WorldGen.cs:5816
Terraria.WorldGen.ShroomPatch
static void ShroomPatch(int i, int j)
Definition WorldGen.cs:70012
Terraria.WorldGen.SquareTileFrame
static void SquareTileFrame(int i, int j, bool resetFrame=true)
Definition WorldGen.cs:70362
Terraria.WorldGen.OrePatch
static bool OrePatch(int X, int Y)
Definition WorldGen.cs:6741
Terraria.WorldGen.gemCave
static void gemCave(int x, int y)
Definition WorldGen.cs:5825
Terraria.WorldGen.placeTrap
static bool placeTrap(int x2, int y2, int type=-1)
Definition WorldGen.cs:5155
Terraria.WorldGen.WavyCaverer
static void WavyCaverer(int startX, int startY, double waveStrengthScalar, double wavePercentScalar, int steps, int type)
Definition WorldGen.cs:66701
Terraria.WorldGen.StonePatch
static bool StonePatch(int X, int Y)
Definition WorldGen.cs:6374
Terraria.WorldGen.WaterCheck
static void WaterCheck()
Definition WorldGen.cs:70574
Terraria.WorldGen.makeTemple
static void makeTemple(int x, int y)
Definition WorldGen.cs:25061
Terraria.WorldGen.notTheBees
static bool notTheBees
Definition WorldGen.cs:1164
Terraria.WorldGen.getGoodWorldGen
static bool getGoodWorldGen
Definition WorldGen.cs:1156
Terraria.WorldGen.PlaceTight
static void PlaceTight(int x, int y, bool spiders=false)
Definition WorldGen.cs:33110
Terraria.WorldGen.AddTrees
static void AddTrees(bool undergroundOnly=false)
Definition WorldGen.cs:23188
Terraria.WorldGen.ClearBrokenTraps
static void ClearBrokenTraps(Point startTileCoords, List< Point > pointsWeAlreadyWentOver)
Definition WorldGen.cs:18520
Terraria.WorldGen.countTiles
static int countTiles(int x, int y, bool jungle=false, bool lavaOk=false)
Definition WorldGen.cs:5679
Terraria.WorldGen.CrimPlaceHearts
static void CrimPlaceHearts()
Definition WorldGen.cs:65586
Terraria.WorldGen.GrowCatTail
static void GrowCatTail(int x, int j)
Definition WorldGen.cs:49908
Terraria.WorldGen.RandomWorldPoint
static Point RandomWorldPoint(int padding)
Definition WorldGen.cs:18775
Terraria.WorldGen.setMoss
static void setMoss(int x, int y)
Definition WorldGen.cs:6006
Terraria.WorldGen.PlaceSandTrap
static bool PlaceSandTrap(int i, int j)
Definition WorldGen.cs:29072
Terraria.WorldGen.Cavinator
static void Cavinator(int i, int j, int steps)
Definition WorldGen.cs:70160
Terraria.WorldGen.FinishGetGoodWorld
static void FinishGetGoodWorld()
Definition WorldGen.cs:17682
Terraria.WorldGen.AddLifeCrystal
static bool AddLifeCrystal(int i, int j)
Definition WorldGen.cs:23696
Terraria.WorldGen.SolidOrSlopedTile
static bool SolidOrSlopedTile(Tile tile)
Definition WorldGen.cs:60621
Terraria.WorldGen.IsTileNearby
static bool IsTileNearby(int x, int y, int type, int distance)
Definition WorldGen.cs:5117
Terraria.WorldGen.FillWallHolesInArea
static void FillWallHolesInArea(Rectangle worldCoordsArea)
Definition WorldGen.cs:6014
ReLogic.Utilities.Vector2D.Distance
static double Distance(Vector2D value1, Vector2D value2)
Definition Vector2D.cs:137

References Terraria.WorldGen._generator, Terraria.WorldGen._genRand, Terraria.WorldGen._lastSeed, System.Math.Abs(), System.Collections.Generic.Dictionary< TKey, TValue >.Add(), Terraria.WorldGen.AddGenerationPass(), Terraria.WorldGen.AddHellHouses(), System.array, Terraria.WorldGen.beachDistance, Terraria.WorldBuilding.GenVars.beachSandDungeonExtraWidth, Terraria.WorldBuilding.GenVars.beachSandJungleExtraWidth, Terraria.WorldBuilding.GenVars.beachSandRandomCenter, Terraria.WorldBuilding.GenVars.beachSandRandomWidthRange, Terraria.GameContent.Biomes.GraniteBiome.CanPlace(), Terraria.WorldGen.CaveOpenater(), Terraria.WorldGen.Caverer(), Terraria.WorldGen.Cavinator(), Terraria.WorldGen.ChasmRunner(), Terraria.Main.checkHalloween(), Terraria.Main.checkXMas(), Terraria.WorldGen.CloudIsland(), Terraria.WorldGen.CloudLake(), Terraria.WorldBuilding.GenVars.configuration, Terraria.WorldBuilding.GenVars.copper, System.Collections.Generic.Dictionary< TKey, TValue >.Count, Terraria.WorldGen.CrimPlaceHearts(), Terraria.WorldGen.crimson, Terraria.WorldBuilding.GenVars.crimsonLeft, Terraria.WorldGen.CrimStart(), Terraria.Main.dayTime, Terraria.WorldGen.DesertCloudIsland(), ReLogic.Utilities.Vector2D.Distance(), Terraria.WorldGen.dontStarveWorldGen, Terraria.WorldGen.drunkWorldGen, Terraria.WorldGen.drunkWorldGenText, Terraria.WorldBuilding.GenVars.dungeonLocation, Terraria.WorldBuilding.GenVars.dungeonSide, System.E, Microsoft.Xna.Framework.Rectangle.Empty, Terraria.WorldGen.everythingWorldGen, Terraria.WorldBuilding.GenVars.evilBiomeAvoidanceMidFixer, Terraria.WorldBuilding.GenVars.evilBiomeBeachAvoidance, Terraria.Main.expertMode, Terraria.WorldBuilding.GenVars.floatingIslandHouseX, Terraria.WorldBuilding.GenVars.floatingIslandHouseY, Terraria.WorldBuilding.GenVars.floatingIslandStyle, Terraria.WorldBuilding.WorldGenConfiguration.FromEmbeddedPath(), Terraria.Lang.gen, Terraria.WorldGen.gen, Terraria.WorldGen.genRand, Terraria.WorldGen.getGoodWorldGen, Terraria.Localization.Language.GetTextValue(), Terraria.WorldBuilding.GenVars.gold, Terraria.WorldGen.grassSpread, Terraria.WorldGen.growGrassUnderground, Terraria.WorldGen.heartCount, System.index, Terraria.WorldGen.InWorld(), Terraria.WorldBuilding.GenVars.iron, Terraria.WorldGen.IsTileNearby(), System.item, Terraria.WorldBuilding.GenVars.jungleHut, Terraria.WorldBuilding.GenVars.jungleOriginX, Terraria.WorldGen.KillTile(), Terraria.WorldBuilding.GenVars.lakesBeachAvoidance, Terraria.WorldBuilding.GenVars.LakeX, Terraria.WorldBuilding.GenVars.lavaLine, Terraria.WorldBuilding.GenVars.leftBeachEnd, Terraria.WorldGen.MakeDungeon(), Terraria.WorldBuilding.GenVars.maxLakes, Terraria.WorldBuilding.GenVars.maxMushroomBiomes, Terraria.Main.maxTilesX, Terraria.Main.maxTilesY, Terraria.WorldBuilding.GenVars.maxTunnels, Terraria.WorldBuilding.GenVars.mCaveX, Terraria.WorldBuilding.GenVars.mCaveY, System.Math.Min(), Terraria.WorldGen.Mountinater(), Terraria.WorldBuilding.GenVars.mushroomBiomesPosition, Terraria.WorldGen.noTileActions, Terraria.WorldGen.noTrapsWorldGen, Terraria.WorldGen.notTheBees, Terraria.WorldGen.NotTheBees(), Terraria.WorldBuilding.GenVars.numIslandHouses, Terraria.WorldBuilding.GenVars.numLakes, Terraria.WorldBuilding.GenVars.numMCaves, Terraria.WorldBuilding.GenVars.numMushroomBiomes, Terraria.WorldBuilding.GenVars.numOceanCaveTreasure, Terraria.WorldBuilding.GenVars.numPyr, Terraria.WorldBuilding.GenVars.numTunnels, Terraria.WorldGen.oceanDepths(), Terraria.WorldBuilding.GenVars.oceanWaterForcedJungleLength, Terraria.WorldBuilding.GenVars.oceanWaterStartRandomMax, Terraria.WorldBuilding.GenVars.oceanWaterStartRandomMin, Terraria.WorldGen.Place3x2(), Terraria.WorldGen.PlaceTile(), Terraria.WorldGen.Hooks.ProcessWorldGenConfig(), Terraria.WorldBuilding.GenVars.PyrX, Terraria.WorldBuilding.GenVars.PyrY, Terraria.Liquid.QuickWater(), Terraria.Main.rand, Terraria.WorldGen.RandomizeBackgrounds(), Terraria.WorldGen.RandomizeCaveBackgrounds(), Terraria.WorldGen.RandomizeMoonState(), Terraria.WorldGen.RandomizeTreeStyle(), Terraria.WorldGen.RandomizeWeather(), Terraria.WorldGen.RandomRectanglePoint(), Terraria.WorldGen.RandomWorldPoint(), Terraria.Liquid.ReInit(), Terraria.Main.remixWorld, Terraria.WorldGen.remixWorldGen, Terraria.WorldGen.ResetGenerator(), Terraria.WorldBuilding.GenVars.rightBeachStart, Terraria.WorldBuilding.GenVars.rockLayer, Terraria.Main.rockLayer, Terraria.WorldBuilding.GenVars.rockLayerHigh, Terraria.WorldBuilding.GenVars.rockLayerLow, Terraria.WorldGen.ScanTileColumnAndRemoveClumps(), Terraria.WorldGen.SetupStatueList(), Terraria.WorldBuilding.GenVars.shellStartXLeft, Terraria.WorldBuilding.GenVars.shellStartXRight, Terraria.WorldGen.ShroomPatch(), Terraria.WorldBuilding.GenVars.silver, Terraria.WorldGen.skipFramingDuringGen, Terraria.WorldBuilding.GenVars.skyLake, Terraria.WorldBuilding.GenVars.skyLakes, Terraria.WorldGen.SmallConsecutivesEliminated, Terraria.WorldGen.SmallConsecutivesFound, Terraria.WorldBuilding.GenVars.smallHolesBeachAvoidance, Terraria.WorldBuilding.GenVars.snowBottom, Terraria.WorldGen.SnowCloudIsland(), Terraria.WorldBuilding.GenVars.snowMaxX, Terraria.WorldBuilding.GenVars.snowMinX, Terraria.WorldBuilding.GenVars.snowOriginLeft, Terraria.WorldBuilding.GenVars.snowOriginRight, Terraria.WorldBuilding.GenVars.snowTop, Terraria.Enums.SolidTile, Terraria.WorldGen.SonOfLakinater(), Terraria.WorldGen.SpreadGrass(), Terraria.WorldBuilding.GenVars.structures, Terraria.WorldBuilding.GenVars.surfaceCavesBeachAvoidance2, Terraria.WorldGen.tempRemixWorldGen, Terraria.WorldGen.tempTenthAnniversaryWorldGen, Terraria.Main.tenthAnniversaryWorld, Terraria.WorldGen.tenthAnniversaryWorldGen, Terraria.DataStructures.Tile, Terraria.Main.tile, Terraria.WorldGen.TileRunner(), Terraria.Main.tileSolid, Terraria.WorldGen.TreeTops, Terraria.WorldGen.TryGrowingTreeByType(), Terraria.WorldGen.TuneOceanDepth(), Terraria.WorldBuilding.GenVars.tunnelX, Terraria.WorldBuilding.GenVars.UndergroundDesertLocation, Terraria.WorldGen.WavyCaverer(), Terraria.WorldGen.WorldGenParam_Evil, Terraria.WorldBuilding.GenVars.worldSurface, Terraria.Main.worldSurface, Terraria.WorldBuilding.GenVars.worldSurfaceHigh, Terraria.WorldBuilding.GenVars.worldSurfaceLow, System.Console.WriteLine(), and Microsoft.Xna.Framework.Point.Zero.

Referenced by Terraria.WorldBuilding.WorldUtils.DebugRegen(), Terraria.Main.Initialize_AlmostEverything(), Terraria.IO.WorldFile.LoadWorld(), and Terraria.WorldGen.worldGenCallback().