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

◆ MakeDungeon()

static void Terraria.WorldGen.MakeDungeon ( int x,
int y )
inlinestatic

Definition at line 26588 of file WorldGen.cs.

26589 {
26590 GenVars.dEnteranceX = 0;
26591 GenVars.numDRooms = 0;
26592 GenVars.numDDoors = 0;
26593 GenVars.numDungeonPlatforms = 0;
26594 int num = genRand.Next(3);
26595 genRand.Next(3);
26596 if (remixWorldGen)
26597 {
26598 num = (crimson ? 2 : 0);
26599 }
26600 ushort num2;
26601 int num3;
26602 switch (num)
26603 {
26604 case 0:
26605 num2 = 41;
26606 num3 = 7;
26607 GenVars.crackedType = 481;
26608 break;
26609 case 1:
26610 num2 = 43;
26611 num3 = 8;
26612 GenVars.crackedType = 482;
26613 break;
26614 default:
26615 num2 = 44;
26616 num3 = 9;
26617 GenVars.crackedType = 483;
26618 break;
26619 }
26620 Main.tileSolid[GenVars.crackedType] = false;
26621 GenVars.dungeonLake = true;
26622 GenVars.numDDoors = 0;
26623 GenVars.numDungeonPlatforms = 0;
26624 GenVars.numDRooms = 0;
26625 GenVars.dungeonX = x;
26626 GenVars.dungeonY = y;
26627 GenVars.dMinX = x;
26628 GenVars.dMaxX = x;
26629 GenVars.dMinY = y;
26630 GenVars.dMaxY = y;
26631 GenVars.dxStrength1 = genRand.Next(25, 30);
26632 GenVars.dyStrength1 = genRand.Next(20, 25);
26633 GenVars.dxStrength2 = genRand.Next(35, 50);
26634 GenVars.dyStrength2 = genRand.Next(10, 15);
26635 double num4 = Main.maxTilesX / 60;
26636 num4 += (double)genRand.Next(0, (int)(num4 / 3.0));
26637 double num5 = num4;
26638 int num6 = 5;
26639 DungeonRoom(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26640 while (num4 > 0.0)
26641 {
26642 if (GenVars.dungeonX < GenVars.dMinX)
26643 {
26644 GenVars.dMinX = GenVars.dungeonX;
26645 }
26646 if (GenVars.dungeonX > GenVars.dMaxX)
26647 {
26648 GenVars.dMaxX = GenVars.dungeonX;
26649 }
26650 if (GenVars.dungeonY > GenVars.dMaxY)
26651 {
26652 GenVars.dMaxY = GenVars.dungeonY;
26653 }
26654 num4 -= 1.0;
26655 Main.statusText = Lang.gen[58].Value + " " + (int)((num5 - num4) / num5 * 60.0) + "%";
26656 if (num6 > 0)
26657 {
26658 num6--;
26659 }
26660 if ((num6 == 0) & (genRand.Next(3) == 0))
26661 {
26662 num6 = 5;
26663 if (genRand.Next(2) == 0)
26664 {
26665 int dungeonX = GenVars.dungeonX;
26666 int dungeonY = GenVars.dungeonY;
26667 DungeonHalls(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26668 if (genRand.Next(2) == 0)
26669 {
26670 DungeonHalls(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26671 }
26672 DungeonRoom(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26673 GenVars.dungeonX = dungeonX;
26674 GenVars.dungeonY = dungeonY;
26675 }
26676 else
26677 {
26678 DungeonRoom(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26679 }
26680 }
26681 else
26682 {
26683 DungeonHalls(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26684 }
26685 }
26686 DungeonRoom(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26687 int num7 = GenVars.dRoomX[0];
26688 int num8 = GenVars.dRoomY[0];
26689 for (int i = 0; i < GenVars.numDRooms; i++)
26690 {
26691 if (GenVars.dRoomY[i] < num8)
26692 {
26693 num7 = GenVars.dRoomX[i];
26694 num8 = GenVars.dRoomY[i];
26695 }
26696 }
26697 GenVars.dungeonX = num7;
26698 GenVars.dungeonY = num8;
26699 GenVars.dEnteranceX = num7;
26700 GenVars.dSurface = false;
26701 num6 = 5;
26702 if (drunkWorldGen)
26703 {
26704 GenVars.dSurface = true;
26705 }
26706 while (!GenVars.dSurface)
26707 {
26708 if (num6 > 0)
26709 {
26710 num6--;
26711 }
26712 if (num6 == 0 && genRand.Next(5) == 0 && (double)GenVars.dungeonY > Main.worldSurface + 100.0)
26713 {
26714 num6 = 10;
26715 int dungeonX2 = GenVars.dungeonX;
26716 int dungeonY2 = GenVars.dungeonY;
26717 DungeonHalls(GenVars.dungeonX, GenVars.dungeonY, num2, num3, forceX: true);
26718 DungeonRoom(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26719 GenVars.dungeonX = dungeonX2;
26720 GenVars.dungeonY = dungeonY2;
26721 }
26722 DungeonStairs(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26723 }
26724 DungeonEnt(GenVars.dungeonX, GenVars.dungeonY, num2, num3);
26725 Main.statusText = Lang.gen[58].Value + " 65%";
26726 int num9 = Main.maxTilesX * 2;
26727 int num10;
26728 for (num10 = 0; num10 < num9; num10++)
26729 {
26730 int i2 = genRand.Next(GenVars.dMinX, GenVars.dMaxX);
26731 int num11 = GenVars.dMinY;
26732 if ((double)num11 < Main.worldSurface)
26733 {
26734 num11 = (int)Main.worldSurface;
26735 }
26736 int j = genRand.Next(num11, GenVars.dMaxY);
26737 num10 = ((!DungeonPitTrap(i2, j, num2, num3)) ? (num10 + 1) : (num10 + 1500));
26738 }
26739 for (int k = 0; k < GenVars.numDRooms; k++)
26740 {
26741 for (int l = GenVars.dRoomL[k]; l <= GenVars.dRoomR[k]; l++)
26742 {
26743 if (!Main.tile[l, GenVars.dRoomT[k] - 1].active())
26744 {
26745 GenVars.dungeonPlatformX[GenVars.numDungeonPlatforms] = l;
26746 GenVars.dungeonPlatformY[GenVars.numDungeonPlatforms] = GenVars.dRoomT[k] - 1;
26747 GenVars.numDungeonPlatforms++;
26748 break;
26749 }
26750 }
26751 for (int m = GenVars.dRoomL[k]; m <= GenVars.dRoomR[k]; m++)
26752 {
26753 if (!Main.tile[m, GenVars.dRoomB[k] + 1].active())
26754 {
26755 GenVars.dungeonPlatformX[GenVars.numDungeonPlatforms] = m;
26756 GenVars.dungeonPlatformY[GenVars.numDungeonPlatforms] = GenVars.dRoomB[k] + 1;
26757 GenVars.numDungeonPlatforms++;
26758 break;
26759 }
26760 }
26761 for (int n = GenVars.dRoomT[k]; n <= GenVars.dRoomB[k]; n++)
26762 {
26763 if (!Main.tile[GenVars.dRoomL[k] - 1, n].active())
26764 {
26765 GenVars.DDoorX[GenVars.numDDoors] = GenVars.dRoomL[k] - 1;
26766 GenVars.DDoorY[GenVars.numDDoors] = n;
26767 GenVars.DDoorPos[GenVars.numDDoors] = -1;
26768 GenVars.numDDoors++;
26769 break;
26770 }
26771 }
26772 for (int num12 = GenVars.dRoomT[k]; num12 <= GenVars.dRoomB[k]; num12++)
26773 {
26774 if (!Main.tile[GenVars.dRoomR[k] + 1, num12].active())
26775 {
26776 GenVars.DDoorX[GenVars.numDDoors] = GenVars.dRoomR[k] + 1;
26777 GenVars.DDoorY[GenVars.numDDoors] = num12;
26778 GenVars.DDoorPos[GenVars.numDDoors] = 1;
26779 GenVars.numDDoors++;
26780 break;
26781 }
26782 }
26783 }
26784 Main.statusText = Lang.gen[58].Value + " 70%";
26785 int num13 = 0;
26786 int num14 = 1000;
26787 int num15 = 0;
26788 int num16 = Main.maxTilesX / 100;
26789 if (getGoodWorldGen)
26790 {
26791 num16 *= 3;
26792 }
26793 while (num15 < num16)
26794 {
26795 num13++;
26796 int num17 = genRand.Next(GenVars.dMinX, GenVars.dMaxX);
26797 int num18 = genRand.Next((int)Main.worldSurface + 25, GenVars.dMaxY);
26798 if (drunkWorldGen)
26799 {
26800 num18 = genRand.Next(GenVars.dungeonY + 25, GenVars.dMaxY);
26801 }
26802 int num19 = num17;
26803 if (Main.tile[num17, num18].wall == num3 && !Main.tile[num17, num18].active())
26804 {
26805 int num20 = 1;
26806 if (genRand.Next(2) == 0)
26807 {
26808 num20 = -1;
26809 }
26810 for (; !Main.tile[num17, num18].active(); num18 += num20)
26811 {
26812 }
26813 if (Main.tile[num17 - 1, num18].active() && Main.tile[num17 + 1, num18].active() && Main.tile[num17 - 1, num18].type != GenVars.crackedType && !Main.tile[num17 - 1, num18 - num20].active() && !Main.tile[num17 + 1, num18 - num20].active())
26814 {
26815 num15++;
26816 int num21 = genRand.Next(5, 13);
26817 while (Main.tile[num17 - 1, num18].active() && Main.tile[num17 - 1, num18].type != GenVars.crackedType && Main.tile[num17, num18 + num20].active() && Main.tile[num17, num18].active() && !Main.tile[num17, num18 - num20].active() && num21 > 0)
26818 {
26819 Main.tile[num17, num18].type = 48;
26820 if (!Main.tile[num17 - 1, num18 - num20].active() && !Main.tile[num17 + 1, num18 - num20].active())
26821 {
26822 Main.tile[num17, num18 - num20].Clear(TileDataType.Slope);
26823 Main.tile[num17, num18 - num20].type = 48;
26824 Main.tile[num17, num18 - num20].active(active: true);
26825 Main.tile[num17, num18 - num20 * 2].Clear(TileDataType.Slope);
26826 Main.tile[num17, num18 - num20 * 2].type = 48;
26827 Main.tile[num17, num18 - num20 * 2].active(active: true);
26828 }
26829 num17--;
26830 num21--;
26831 }
26832 num21 = genRand.Next(5, 13);
26833 num17 = num19 + 1;
26834 while (Main.tile[num17 + 1, num18].active() && Main.tile[num17 + 1, num18].type != GenVars.crackedType && Main.tile[num17, num18 + num20].active() && Main.tile[num17, num18].active() && !Main.tile[num17, num18 - num20].active() && num21 > 0)
26835 {
26836 Main.tile[num17, num18].type = 48;
26837 if (!Main.tile[num17 - 1, num18 - num20].active() && !Main.tile[num17 + 1, num18 - num20].active())
26838 {
26839 Main.tile[num17, num18 - num20].Clear(TileDataType.Slope);
26840 Main.tile[num17, num18 - num20].type = 48;
26841 Main.tile[num17, num18 - num20].active(active: true);
26842 Main.tile[num17, num18 - num20 * 2].Clear(TileDataType.Slope);
26843 Main.tile[num17, num18 - num20 * 2].type = 48;
26844 Main.tile[num17, num18 - num20 * 2].active(active: true);
26845 }
26846 num17++;
26847 num21--;
26848 }
26849 }
26850 }
26851 if (num13 > num14)
26852 {
26853 num13 = 0;
26854 num15++;
26855 }
26856 }
26857 num13 = 0;
26858 num14 = 1000;
26859 num15 = 0;
26860 Main.statusText = Lang.gen[58].Value + " 75%";
26861 while (num15 < num16)
26862 {
26863 num13++;
26864 int num22 = genRand.Next(GenVars.dMinX, GenVars.dMaxX);
26865 int num23 = genRand.Next((int)Main.worldSurface + 25, GenVars.dMaxY);
26866 int num24 = num23;
26867 if (Main.tile[num22, num23].wall == num3 && !Main.tile[num22, num23].active())
26868 {
26869 int num25 = 1;
26870 if (genRand.Next(2) == 0)
26871 {
26872 num25 = -1;
26873 }
26874 for (; num22 > 5 && num22 < Main.maxTilesX - 5 && !Main.tile[num22, num23].active(); num22 += num25)
26875 {
26876 }
26877 if (Main.tile[num22, num23 - 1].active() && Main.tile[num22, num23 + 1].active() && Main.tile[num22, num23 - 1].type != GenVars.crackedType && !Main.tile[num22 - num25, num23 - 1].active() && !Main.tile[num22 - num25, num23 + 1].active())
26878 {
26879 num15++;
26880 int num26 = genRand.Next(5, 13);
26881 while (Main.tile[num22, num23 - 1].active() && Main.tile[num22, num23 - 1].type != GenVars.crackedType && Main.tile[num22 + num25, num23].active() && Main.tile[num22, num23].active() && !Main.tile[num22 - num25, num23].active() && num26 > 0)
26882 {
26883 Main.tile[num22, num23].type = 48;
26884 if (!Main.tile[num22 - num25, num23 - 1].active() && !Main.tile[num22 - num25, num23 + 1].active())
26885 {
26886 Main.tile[num22 - num25, num23].type = 48;
26887 Main.tile[num22 - num25, num23].active(active: true);
26888 Main.tile[num22 - num25, num23].Clear(TileDataType.Slope);
26889 Main.tile[num22 - num25 * 2, num23].type = 48;
26890 Main.tile[num22 - num25 * 2, num23].active(active: true);
26891 Main.tile[num22 - num25 * 2, num23].Clear(TileDataType.Slope);
26892 }
26893 num23--;
26894 num26--;
26895 }
26896 num26 = genRand.Next(5, 13);
26897 num23 = num24 + 1;
26898 while (Main.tile[num22, num23 + 1].active() && Main.tile[num22, num23 + 1].type != GenVars.crackedType && Main.tile[num22 + num25, num23].active() && Main.tile[num22, num23].active() && !Main.tile[num22 - num25, num23].active() && num26 > 0)
26899 {
26900 Main.tile[num22, num23].type = 48;
26901 if (!Main.tile[num22 - num25, num23 - 1].active() && !Main.tile[num22 - num25, num23 + 1].active())
26902 {
26903 Main.tile[num22 - num25, num23].type = 48;
26904 Main.tile[num22 - num25, num23].active(active: true);
26905 Main.tile[num22 - num25, num23].Clear(TileDataType.Slope);
26906 Main.tile[num22 - num25 * 2, num23].type = 48;
26907 Main.tile[num22 - num25 * 2, num23].active(active: true);
26908 Main.tile[num22 - num25 * 2, num23].Clear(TileDataType.Slope);
26909 }
26910 num23++;
26911 num26--;
26912 }
26913 }
26914 }
26915 if (num13 > num14)
26916 {
26917 num13 = 0;
26918 num15++;
26919 }
26920 }
26921 Main.statusText = Lang.gen[58].Value + " 80%";
26922 for (int num27 = 0; num27 < GenVars.numDDoors; num27++)
26923 {
26924 int num28 = GenVars.DDoorX[num27] - 10;
26925 int num29 = GenVars.DDoorX[num27] + 10;
26926 int num30 = 100;
26927 int num31 = 0;
26928 int num32 = 0;
26929 int num33 = 0;
26930 for (int num34 = num28; num34 < num29; num34++)
26931 {
26932 bool flag = true;
26933 int num35 = GenVars.DDoorY[num27];
26934 while (num35 > 10 && !Main.tile[num34, num35].active())
26935 {
26936 num35--;
26937 }
26938 if (!Main.tileDungeon[Main.tile[num34, num35].type])
26939 {
26940 flag = false;
26941 }
26942 num32 = num35;
26943 for (num35 = GenVars.DDoorY[num27]; !Main.tile[num34, num35].active(); num35++)
26944 {
26945 }
26946 if (!Main.tileDungeon[Main.tile[num34, num35].type])
26947 {
26948 flag = false;
26949 }
26950 num33 = num35;
26951 if (num33 - num32 < 3)
26952 {
26953 continue;
26954 }
26955 int num36 = num34 - 20;
26956 int num37 = num34 + 20;
26957 int num38 = num33 - 10;
26958 int num39 = num33 + 10;
26959 for (int num40 = num36; num40 < num37; num40++)
26960 {
26961 for (int num41 = num38; num41 < num39; num41++)
26962 {
26963 if (Main.tile[num40, num41].active() && Main.tile[num40, num41].type == 10)
26964 {
26965 flag = false;
26966 break;
26967 }
26968 }
26969 }
26970 if (flag)
26971 {
26972 for (int num42 = num33 - 3; num42 < num33; num42++)
26973 {
26974 for (int num43 = num34 - 3; num43 <= num34 + 3; num43++)
26975 {
26976 if (Main.tile[num43, num42].active())
26977 {
26978 flag = false;
26979 break;
26980 }
26981 }
26982 }
26983 }
26984 if (flag && num33 - num32 < 20)
26985 {
26986 bool flag2 = false;
26987 if (GenVars.DDoorPos[num27] == 0 && num33 - num32 < num30)
26988 {
26989 flag2 = true;
26990 }
26991 if (GenVars.DDoorPos[num27] == -1 && num34 > num31)
26992 {
26993 flag2 = true;
26994 }
26995 if (GenVars.DDoorPos[num27] == 1 && (num34 < num31 || num31 == 0))
26996 {
26997 flag2 = true;
26998 }
26999 if (flag2)
27000 {
27001 num31 = num34;
27002 num30 = num33 - num32;
27003 }
27004 }
27005 }
27006 if (num30 >= 20)
27007 {
27008 continue;
27009 }
27010 int num44 = num31;
27011 int num45 = GenVars.DDoorY[num27];
27012 int num46 = num45;
27013 for (; !Main.tile[num44, num45].active(); num45++)
27014 {
27015 Main.tile[num44, num45].active(active: false);
27016 }
27017 while (!Main.tile[num44, num46].active())
27018 {
27019 num46--;
27020 }
27021 num45--;
27022 num46++;
27023 for (int num47 = num46; num47 < num45 - 2; num47++)
27024 {
27025 Main.tile[num44, num47].Clear(TileDataType.Slope);
27026 Main.tile[num44, num47].active(active: true);
27027 Main.tile[num44, num47].type = num2;
27028 if (Main.tile[num44 - 1, num47].type == num2)
27029 {
27030 Main.tile[num44 - 1, num47].active(active: false);
27031 Main.tile[num44 - 1, num47].ClearEverything();
27032 Main.tile[num44 - 1, num47].wall = (ushort)num3;
27033 }
27034 if (Main.tile[num44 - 2, num47].type == num2)
27035 {
27036 Main.tile[num44 - 2, num47].active(active: false);
27037 Main.tile[num44 - 2, num47].ClearEverything();
27038 Main.tile[num44 - 2, num47].wall = (ushort)num3;
27039 }
27040 if (Main.tile[num44 + 1, num47].type == num2)
27041 {
27042 Main.tile[num44 + 1, num47].active(active: false);
27043 Main.tile[num44 + 1, num47].ClearEverything();
27044 Main.tile[num44 + 1, num47].wall = (ushort)num3;
27045 }
27046 if (Main.tile[num44 + 2, num47].type == num2)
27047 {
27048 Main.tile[num44 + 2, num47].active(active: false);
27049 Main.tile[num44 + 2, num47].ClearEverything();
27050 Main.tile[num44 + 2, num47].wall = (ushort)num3;
27051 }
27052 }
27053 int style = 13;
27054 if (genRand.Next(3) == 0)
27055 {
27056 switch (num3)
27057 {
27058 case 7:
27059 style = 16;
27060 break;
27061 case 8:
27062 style = 17;
27063 break;
27064 case 9:
27065 style = 18;
27066 break;
27067 }
27068 }
27069 PlaceTile(num44, num45, 10, mute: true, forced: false, -1, style);
27070 num44--;
27071 int num48 = num45 - 3;
27072 while (!Main.tile[num44, num48].active())
27073 {
27074 num48--;
27075 }
27076 if (num45 - num48 < num45 - num46 + 5 && Main.tileDungeon[Main.tile[num44, num48].type])
27077 {
27078 for (int num49 = num45 - 4 - genRand.Next(3); num49 > num48; num49--)
27079 {
27080 Main.tile[num44, num49].Clear(TileDataType.Slope);
27081 Main.tile[num44, num49].active(active: true);
27082 Main.tile[num44, num49].type = num2;
27083 if (Main.tile[num44 - 1, num49].type == num2)
27084 {
27085 Main.tile[num44 - 1, num49].active(active: false);
27086 Main.tile[num44 - 1, num49].ClearEverything();
27087 Main.tile[num44 - 1, num49].wall = (ushort)num3;
27088 }
27089 if (Main.tile[num44 - 2, num49].type == num2)
27090 {
27091 Main.tile[num44 - 2, num49].active(active: false);
27092 Main.tile[num44 - 2, num49].ClearEverything();
27093 Main.tile[num44 - 2, num49].wall = (ushort)num3;
27094 }
27095 }
27096 }
27097 num44 += 2;
27098 num48 = num45 - 3;
27099 while (!Main.tile[num44, num48].active())
27100 {
27101 num48--;
27102 }
27103 if (num45 - num48 < num45 - num46 + 5 && Main.tileDungeon[Main.tile[num44, num48].type])
27104 {
27105 for (int num50 = num45 - 4 - genRand.Next(3); num50 > num48; num50--)
27106 {
27107 Main.tile[num44, num50].active(active: true);
27108 Main.tile[num44, num50].Clear(TileDataType.Slope);
27109 Main.tile[num44, num50].type = num2;
27110 if (Main.tile[num44 + 1, num50].type == num2)
27111 {
27112 Main.tile[num44 + 1, num50].active(active: false);
27113 Main.tile[num44 + 1, num50].ClearEverything();
27114 Main.tile[num44 + 1, num50].wall = (ushort)num3;
27115 }
27116 if (Main.tile[num44 + 2, num50].type == num2)
27117 {
27118 Main.tile[num44 + 2, num50].active(active: false);
27119 Main.tile[num44 + 2, num50].ClearEverything();
27120 Main.tile[num44 + 2, num50].wall = (ushort)num3;
27121 }
27122 }
27123 }
27124 num45++;
27125 num44--;
27126 for (int num51 = num45 - 8; num51 < num45; num51++)
27127 {
27128 if (Main.tile[num44 + 2, num51].type == num2)
27129 {
27130 Main.tile[num44 + 2, num51].active(active: false);
27131 Main.tile[num44 + 2, num51].ClearEverything();
27132 Main.tile[num44 + 2, num51].wall = (ushort)num3;
27133 }
27134 if (Main.tile[num44 + 3, num51].type == num2)
27135 {
27136 Main.tile[num44 + 3, num51].active(active: false);
27137 Main.tile[num44 + 3, num51].ClearEverything();
27138 Main.tile[num44 + 3, num51].wall = (ushort)num3;
27139 }
27140 if (Main.tile[num44 - 2, num51].type == num2)
27141 {
27142 Main.tile[num44 - 2, num51].active(active: false);
27143 Main.tile[num44 - 2, num51].ClearEverything();
27144 Main.tile[num44 - 2, num51].wall = (ushort)num3;
27145 }
27146 if (Main.tile[num44 - 3, num51].type == num2)
27147 {
27148 Main.tile[num44 - 3, num51].active(active: false);
27149 Main.tile[num44 - 3, num51].ClearEverything();
27150 Main.tile[num44 - 3, num51].wall = (ushort)num3;
27151 }
27152 }
27153 Main.tile[num44 - 1, num45].active(active: true);
27154 Main.tile[num44 - 1, num45].type = num2;
27155 Main.tile[num44 - 1, num45].Clear(TileDataType.Slope);
27156 Main.tile[num44 + 1, num45].active(active: true);
27157 Main.tile[num44 + 1, num45].type = num2;
27158 Main.tile[num44 + 1, num45].Clear(TileDataType.Slope);
27159 }
27160 int[] array = new int[3];
27161 switch (num3)
27162 {
27163 case 7:
27164 array[0] = 7;
27165 array[1] = 94;
27166 array[2] = 95;
27167 break;
27168 case 9:
27169 array[0] = 9;
27170 array[1] = 96;
27171 array[2] = 97;
27172 break;
27173 default:
27174 array[0] = 8;
27175 array[1] = 98;
27176 array[2] = 99;
27177 break;
27178 }
27179 for (int num52 = 0; num52 < 5; num52++)
27180 {
27181 for (int num53 = 0; num53 < 3; num53++)
27182 {
27183 int num54 = genRand.Next(40, 240);
27184 int num55 = genRand.Next(GenVars.dMinX, GenVars.dMaxX);
27185 int num56 = genRand.Next(GenVars.dMinY, GenVars.dMaxY);
27186 for (int num57 = num55 - num54; num57 < num55 + num54; num57++)
27187 {
27188 for (int num58 = num56 - num54; num58 < num56 + num54; num58++)
27189 {
27190 if ((double)num58 > Main.worldSurface)
27191 {
27192 double num59 = Math.Abs(num55 - num57);
27193 double num60 = Math.Abs(num56 - num58);
27194 if (Math.Sqrt(num59 * num59 + num60 * num60) < (double)num54 * 0.4 && Main.wallDungeon[Main.tile[num57, num58].wall])
27195 {
27196 Spread.WallDungeon(num57, num58, array[num53]);
27197 }
27198 }
27199 }
27200 }
27201 }
27202 }
27203 Main.statusText = Lang.gen[58].Value + " 85%";
27204 for (int num61 = 0; num61 < GenVars.numDungeonPlatforms; num61++)
27205 {
27206 int num62 = GenVars.dungeonPlatformX[num61];
27207 int num63 = GenVars.dungeonPlatformY[num61];
27208 int num64 = Main.maxTilesX;
27209 int num65 = 10;
27210 if ((double)num63 < Main.worldSurface + 50.0)
27211 {
27212 num65 = 20;
27213 }
27214 for (int num66 = num63 - 5; num66 <= num63 + 5; num66++)
27215 {
27216 int num67 = num62;
27217 int num68 = num62;
27218 bool flag3 = false;
27219 if (Main.tile[num67, num66].active())
27220 {
27221 flag3 = true;
27222 }
27223 else
27224 {
27225 while (!Main.tile[num67, num66].active())
27226 {
27227 num67--;
27228 if (!Main.tileDungeon[Main.tile[num67, num66].type] || num67 == 0)
27229 {
27230 flag3 = true;
27231 break;
27232 }
27233 }
27234 while (!Main.tile[num68, num66].active())
27235 {
27236 num68++;
27237 if (!Main.tileDungeon[Main.tile[num68, num66].type] || num68 == Main.maxTilesX - 1)
27238 {
27239 flag3 = true;
27240 break;
27241 }
27242 }
27243 }
27244 if (flag3 || num68 - num67 > num65)
27245 {
27246 continue;
27247 }
27248 bool flag4 = true;
27249 int num69 = num62 - num65 / 2 - 2;
27250 int num70 = num62 + num65 / 2 + 2;
27251 int num71 = num66 - 5;
27252 int num72 = num66 + 5;
27253 for (int num73 = num69; num73 <= num70; num73++)
27254 {
27255 for (int num74 = num71; num74 <= num72; num74++)
27256 {
27257 if (Main.tile[num73, num74].active() && Main.tile[num73, num74].type == 19)
27258 {
27259 flag4 = false;
27260 break;
27261 }
27262 }
27263 }
27264 for (int num75 = num66 + 3; num75 >= num66 - 5; num75--)
27265 {
27266 if (Main.tile[num62, num75].active())
27267 {
27268 flag4 = false;
27269 break;
27270 }
27271 }
27272 if (flag4)
27273 {
27274 num64 = num66;
27275 break;
27276 }
27277 }
27278 if (num64 <= num63 - 10 || num64 >= num63 + 10)
27279 {
27280 continue;
27281 }
27282 int num76 = num62;
27283 int num77 = num64;
27284 int num78 = num62 + 1;
27285 while (!Main.tile[num76, num77].active())
27286 {
27287 Main.tile[num76, num77].active(active: true);
27288 Main.tile[num76, num77].type = 19;
27289 Main.tile[num76, num77].Clear(TileDataType.Slope);
27290 switch (num3)
27291 {
27292 case 7:
27293 Main.tile[num76, num77].frameY = 108;
27294 break;
27295 case 8:
27296 Main.tile[num76, num77].frameY = 144;
27297 break;
27298 default:
27299 Main.tile[num76, num77].frameY = 126;
27300 break;
27301 }
27302 TileFrame(num76, num77);
27303 num76--;
27304 }
27305 for (; !Main.tile[num78, num77].active(); num78++)
27306 {
27307 Main.tile[num78, num77].active(active: true);
27308 Main.tile[num78, num77].type = 19;
27309 Main.tile[num78, num77].Clear(TileDataType.Slope);
27310 switch (num3)
27311 {
27312 case 7:
27313 Main.tile[num78, num77].frameY = 108;
27314 break;
27315 case 8:
27316 Main.tile[num78, num77].frameY = 144;
27317 break;
27318 default:
27319 Main.tile[num78, num77].frameY = 126;
27320 break;
27321 }
27322 TileFrame(num78, num77);
27323 }
27324 }
27325 int num79 = 5;
27326 if (drunkWorldGen)
27327 {
27328 num79 = 6;
27329 }
27330 for (int num80 = 0; num80 < num79; num80++)
27331 {
27332 bool flag5 = false;
27333 while (!flag5)
27334 {
27335 int num81 = genRand.Next(GenVars.dMinX, GenVars.dMaxX);
27336 int num82 = genRand.Next((int)Main.worldSurface, GenVars.dMaxY);
27337 if (!Main.wallDungeon[Main.tile[num81, num82].wall] || Main.tile[num81, num82].active())
27338 {
27339 continue;
27340 }
27341 ushort chestTileType = 21;
27342 int contain = 0;
27343 int style2 = 0;
27344 switch (num80)
27345 {
27346 case 0:
27347 style2 = 23;
27348 contain = 1156;
27349 break;
27350 case 1:
27351 if (!crimson)
27352 {
27353 style2 = 24;
27354 contain = 1571;
27355 }
27356 else
27357 {
27358 style2 = 25;
27359 contain = 1569;
27360 }
27361 break;
27362 case 5:
27363 if (crimson)
27364 {
27365 style2 = 24;
27366 contain = 1571;
27367 }
27368 else
27369 {
27370 style2 = 25;
27371 contain = 1569;
27372 }
27373 break;
27374 case 2:
27375 style2 = 26;
27376 contain = 1260;
27377 break;
27378 case 3:
27379 style2 = 27;
27380 contain = 1572;
27381 break;
27382 case 4:
27383 chestTileType = 467;
27384 style2 = 13;
27385 contain = 4607;
27386 break;
27387 }
27388 flag5 = AddBuriedChest(num81, num82, contain, notNearOtherChests: false, style2, trySlope: false, chestTileType);
27389 }
27390 }
27391 int[] array2 = new int[3]
27392 {
27393 genRand.Next(9, 13),
27394 genRand.Next(9, 13),
27395 0
27396 };
27397 while (array2[1] == array2[0])
27398 {
27399 array2[1] = genRand.Next(9, 13);
27400 }
27401 array2[2] = genRand.Next(9, 13);
27402 while (array2[2] == array2[0] || array2[2] == array2[1])
27403 {
27404 array2[2] = genRand.Next(9, 13);
27405 }
27406 Main.statusText = Lang.gen[58].Value + " 90%";
27407 num13 = 0;
27408 num14 = 1000;
27409 num15 = 0;
27410 while (num15 < Main.maxTilesX / 20)
27411 {
27412 num13++;
27413 int num83 = genRand.Next(GenVars.dMinX, GenVars.dMaxX);
27414 int num84 = genRand.Next(GenVars.dMinY, GenVars.dMaxY);
27415 bool flag6 = true;
27416 if (Main.wallDungeon[Main.tile[num83, num84].wall] && !Main.tile[num83, num84].active())
27417 {
27418 int num85 = 1;
27419 if (genRand.Next(2) == 0)
27420 {
27421 num85 = -1;
27422 }
27423 while (flag6 && !Main.tile[num83, num84].active())
27424 {
27425 num83 -= num85;
27426 if (num83 < 5 || num83 > Main.maxTilesX - 5)
27427 {
27428 flag6 = false;
27429 }
27430 else if (Main.tile[num83, num84].active() && !Main.tileDungeon[Main.tile[num83, num84].type])
27431 {
27432 flag6 = false;
27433 }
27434 }
27435 if (flag6 && Main.tile[num83, num84].active() && Main.tileDungeon[Main.tile[num83, num84].type] && Main.tile[num83, num84 - 1].active() && Main.tileDungeon[Main.tile[num83, num84 - 1].type] && Main.tile[num83, num84 + 1].active() && Main.tileDungeon[Main.tile[num83, num84 + 1].type])
27436 {
27437 num83 += num85;
27438 for (int num86 = num83 - 3; num86 <= num83 + 3; num86++)
27439 {
27440 for (int num87 = num84 - 3; num87 <= num84 + 3; num87++)
27441 {
27442 if (Main.tile[num86, num87].active() && Main.tile[num86, num87].type == 19)
27443 {
27444 flag6 = false;
27445 break;
27446 }
27447 }
27448 }
27449 if (flag6 && (!Main.tile[num83, num84 - 1].active() & !Main.tile[num83, num84 - 2].active() & !Main.tile[num83, num84 - 3].active()))
27450 {
27451 int num88 = num83;
27452 int num89 = num83;
27453 for (; num88 > GenVars.dMinX && num88 < GenVars.dMaxX && !Main.tile[num88, num84].active() && !Main.tile[num88, num84 - 1].active() && !Main.tile[num88, num84 + 1].active(); num88 += num85)
27454 {
27455 }
27456 num88 = Math.Abs(num83 - num88);
27457 bool flag7 = false;
27458 if (genRand.Next(2) == 0)
27459 {
27460 flag7 = true;
27461 }
27462 if (num88 > 5)
27463 {
27464 for (int num90 = genRand.Next(1, 4); num90 > 0; num90--)
27465 {
27466 Main.tile[num83, num84].active(active: true);
27467 Main.tile[num83, num84].Clear(TileDataType.Slope);
27468 Main.tile[num83, num84].type = 19;
27469 if (Main.tile[num83, num84].wall == array[0])
27470 {
27471 Main.tile[num83, num84].frameY = (short)(18 * array2[0]);
27472 }
27473 else if (Main.tile[num83, num84].wall == array[1])
27474 {
27475 Main.tile[num83, num84].frameY = (short)(18 * array2[1]);
27476 }
27477 else
27478 {
27479 Main.tile[num83, num84].frameY = (short)(18 * array2[2]);
27480 }
27481 TileFrame(num83, num84);
27482 if (flag7)
27483 {
27484 PlaceTile(num83, num84 - 1, 50, mute: true);
27485 if (genRand.Next(50) == 0 && (double)num84 > (Main.worldSurface + Main.rockLayer) / 2.0 && Main.tile[num83, num84 - 1].type == 50)
27486 {
27487 Main.tile[num83, num84 - 1].frameX = 90;
27488 }
27489 }
27490 num83 += num85;
27491 }
27492 num13 = 0;
27493 num15++;
27494 if (!flag7 && genRand.Next(2) == 0)
27495 {
27496 num83 = num89;
27497 num84--;
27498 int num91 = 0;
27499 if (genRand.Next(4) == 0)
27500 {
27501 num91 = 1;
27502 }
27503 switch (num91)
27504 {
27505 case 0:
27506 num91 = 13;
27507 break;
27508 case 1:
27509 num91 = 49;
27510 break;
27511 }
27512 PlaceTile(num83, num84, num91, mute: true);
27513 if (Main.tile[num83, num84].type == 13)
27514 {
27515 if (genRand.Next(2) == 0)
27516 {
27517 Main.tile[num83, num84].frameX = 18;
27518 }
27519 else
27520 {
27521 Main.tile[num83, num84].frameX = 36;
27522 }
27523 }
27524 }
27525 }
27526 }
27527 }
27528 }
27529 if (num13 > num14)
27530 {
27531 num13 = 0;
27532 num15++;
27533 }
27534 }
27535 Main.statusText = Lang.gen[58].Value + " 95%";
27536 int num92 = 1;
27537 for (int num93 = 0; num93 < GenVars.numDRooms; num93++)
27538 {
27539 int num94 = 0;
27540 while (num94 < 1000)
27541 {
27542 int num95 = (int)((double)GenVars.dRoomSize[num93] * 0.4);
27543 int i3 = GenVars.dRoomX[num93] + genRand.Next(-num95, num95 + 1);
27544 int num96 = GenVars.dRoomY[num93] + genRand.Next(-num95, num95 + 1);
27545 int num97 = 0;
27546 int style3 = 2;
27547 if (num92 == 1)
27548 {
27549 num92++;
27550 }
27551 switch (num92)
27552 {
27553 case 2:
27554 num97 = 155;
27555 break;
27556 case 3:
27557 num97 = 156;
27558 break;
27559 case 4:
27560 num97 = ((!remixWorldGen) ? 157 : 2623);
27561 break;
27562 case 5:
27563 num97 = 163;
27564 break;
27565 case 6:
27566 num97 = 113;
27567 break;
27568 case 7:
27569 num97 = 3317;
27570 break;
27571 case 8:
27572 num97 = 327;
27573 style3 = 0;
27574 break;
27575 default:
27576 num97 = 164;
27577 num92 = 0;
27578 break;
27579 }
27580 if ((double)num96 < Main.worldSurface + 50.0)
27581 {
27582 num97 = 327;
27583 style3 = 0;
27584 }
27585 if (num97 == 0 && genRand.Next(2) == 0)
27586 {
27587 num94 = 1000;
27588 continue;
27589 }
27590 if (AddBuriedChest(i3, num96, num97, notNearOtherChests: false, style3, trySlope: false, 0))
27591 {
27592 num94 += 1000;
27593 num92++;
27594 }
27595 num94++;
27596 }
27597 }
27598 GenVars.dMinX -= 25;
27599 GenVars.dMaxX += 25;
27600 GenVars.dMinY -= 25;
27601 GenVars.dMaxY += 25;
27602 if (GenVars.dMinX < 0)
27603 {
27604 GenVars.dMinX = 0;
27605 }
27606 if (GenVars.dMaxX > Main.maxTilesX)
27607 {
27608 GenVars.dMaxX = Main.maxTilesX;
27609 }
27610 if (GenVars.dMinY < 0)
27611 {
27612 GenVars.dMinY = 0;
27613 }
27614 if (GenVars.dMaxY > Main.maxTilesY)
27615 {
27616 GenVars.dMaxY = Main.maxTilesY;
27617 }
27618 num13 = 0;
27619 num14 = 1000;
27620 num15 = 0;
27621 MakeDungeon_Lights(num2, ref num13, num14, ref num15, array);
27622 num13 = 0;
27623 num14 = 1000;
27624 num15 = 0;
27625 MakeDungeon_Traps(ref num13, num14, ref num15);
27626 double count = MakeDungeon_GroundFurniture(num3);
27627 count = MakeDungeon_Pictures(array, count);
27628 count = MakeDungeon_Banners(array, count);
27629 }
System.Math.Sqrt
static double Sqrt(double d)
System.Math.Abs
static double Abs(double value)
Terraria.WorldGen.MakeDungeon_GroundFurniture
static double MakeDungeon_GroundFurniture(int wallType)
Definition WorldGen.cs:28168
Terraria.WorldGen.remixWorldGen
static bool remixWorldGen
Definition WorldGen.cs:1148
Terraria.WorldGen.MakeDungeon_Banners
static double MakeDungeon_Banners(int[] roomWall, double count)
Definition WorldGen.cs:27861
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.genRand
static UnifiedRandom genRand
Definition WorldGen.cs:1215
Terraria.WorldGen.MakeDungeon_Lights
static void MakeDungeon_Lights(ushort tileType, ref int failCount, int failMax, ref int numAdd, int[] roomWall)
Definition WorldGen.cs:27654
Terraria.WorldGen.DungeonEnt
static void DungeonEnt(int i, int j, ushort tileType, int wallType)
Definition WorldGen.cs:30217
Terraria.WorldGen.crimson
static bool crimson
Definition WorldGen.cs:932
Terraria.WorldGen.DungeonStairs
static void DungeonStairs(int i, int j, ushort tileType, int wallType)
Definition WorldGen.cs:28897
Terraria.WorldGen.AddBuriedChest
static bool AddBuriedChest(Point point, int contain=0, bool notNearOtherChests=false, int Style=-1)
Definition WorldGen.cs:30881
Terraria.WorldGen.TileFrame
static void TileFrame(int i, int j, bool resetFrame=false, bool noBreak=false)
Definition WorldGen.cs:71431
Terraria.WorldGen.DungeonPitTrap
static bool DungeonPitTrap(int i, int j, ushort tileType, int wallType)
Definition WorldGen.cs:29339
Terraria.WorldGen.DungeonHalls
static void DungeonHalls(int i, int j, ushort tileType, int wallType, bool forceX=false)
Definition WorldGen.cs:29472
Terraria.WorldGen.drunkWorldGen
static bool drunkWorldGen
Definition WorldGen.cs:1154
Terraria.WorldGen.MakeDungeon_Traps
static void MakeDungeon_Traps(ref int failCount, int failMax, ref int numAdd)
Definition WorldGen.cs:27631
Terraria.WorldGen.getGoodWorldGen
static bool getGoodWorldGen
Definition WorldGen.cs:1156
Terraria.WorldGen.MakeDungeon_Pictures
static double MakeDungeon_Pictures(int[] roomWall, double count)
Definition WorldGen.cs:27911
Terraria.WorldGen.DungeonRoom
static void DungeonRoom(int i, int j, ushort tileType, int wallType)
Definition WorldGen.cs:30051

References System.Math.Abs(), System.array, System.count, Terraria.WorldBuilding.GenVars.crackedType, Terraria.WorldBuilding.GenVars.DDoorPos, Terraria.WorldBuilding.GenVars.DDoorX, Terraria.WorldBuilding.GenVars.DDoorY, Terraria.WorldBuilding.GenVars.dMaxX, Terraria.WorldBuilding.GenVars.dMaxY, Terraria.WorldBuilding.GenVars.dMinX, Terraria.WorldBuilding.GenVars.dMinY, Terraria.WorldBuilding.GenVars.dRoomB, Terraria.WorldBuilding.GenVars.dRoomL, Terraria.WorldBuilding.GenVars.dRoomR, Terraria.WorldBuilding.GenVars.dRoomSize, Terraria.WorldBuilding.GenVars.dRoomT, Terraria.WorldBuilding.GenVars.dRoomX, Terraria.WorldBuilding.GenVars.dRoomY, Terraria.WorldBuilding.GenVars.dSurface, Terraria.WorldBuilding.GenVars.dungeonPlatformX, Terraria.WorldBuilding.GenVars.dungeonPlatformY, Terraria.WorldBuilding.GenVars.dungeonX, Terraria.WorldBuilding.GenVars.dungeonY, Terraria.Lang.gen, Terraria.Main.maxTilesX, Terraria.Main.maxTilesY, Terraria.WorldBuilding.GenVars.numDDoors, Terraria.WorldBuilding.GenVars.numDRooms, Terraria.WorldBuilding.GenVars.numDungeonPlatforms, Terraria.Main.rockLayer, System.Math.Sqrt(), Terraria.Main.tile, Terraria.Main.tileDungeon, Terraria.Main.tileSolid, Terraria.Main.wallDungeon, Terraria.WorldGen.Spread.WallDungeon(), and Terraria.Main.worldSurface.

Referenced by Terraria.WorldGen.GenerateWorld().