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

◆ makeTemple()

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

Definition at line 25061 of file WorldGen.cs.

25062 {
25063 //IL_0940: Unknown result type (might be due to invalid IL or missing references)
25064 //IL_0946: Unknown result type (might be due to invalid IL or missing references)
25065 //IL_094b: Unknown result type (might be due to invalid IL or missing references)
25066 //IL_094d: Unknown result type (might be due to invalid IL or missing references)
25067 //IL_0959: Unknown result type (might be due to invalid IL or missing references)
25068 //IL_0c37: Unknown result type (might be due to invalid IL or missing references)
25069 //IL_0c3d: Unknown result type (might be due to invalid IL or missing references)
25070 //IL_0c42: Unknown result type (might be due to invalid IL or missing references)
25071 //IL_0c44: Unknown result type (might be due to invalid IL or missing references)
25072 //IL_0c50: Unknown result type (might be due to invalid IL or missing references)
25073 //IL_0b55: Unknown result type (might be due to invalid IL or missing references)
25074 //IL_0b5b: Unknown result type (might be due to invalid IL or missing references)
25075 //IL_0b60: Unknown result type (might be due to invalid IL or missing references)
25076 //IL_0b62: Unknown result type (might be due to invalid IL or missing references)
25077 //IL_0b6e: Unknown result type (might be due to invalid IL or missing references)
25078 //IL_0e9b: Unknown result type (might be due to invalid IL or missing references)
25079 //IL_0ea8: Unknown result type (might be due to invalid IL or missing references)
25080 //IL_0f6e: Unknown result type (might be due to invalid IL or missing references)
25081 Rectangle[] array = new Rectangle[100];
25082 double num = (double)Main.maxTilesX / 4200.0;
25083 int num2 = genRand.Next((int)(num * 10.0), (int)(num * 16.0));
25084 if (drunkWorldGen)
25085 {
25086 num2 *= 3;
25087 }
25088 else if (getGoodWorldGen)
25089 {
25090 num2 *= 3;
25091 }
25092 else if (remixWorldGen)
25093 {
25094 num2 *= 2;
25095 }
25096 int num3 = 1;
25097 if (genRand.Next(2) == 0)
25098 {
25099 num3 = -1;
25100 }
25101 int num4 = num3;
25102 int num5 = x;
25103 int num6 = y;
25104 int num7 = x;
25105 int num8 = y;
25106 int num9 = genRand.Next(1, 3);
25107 int num10 = 0;
25108 for (int i = 0; i < num2; i++)
25109 {
25110 num10++;
25111 int num11 = num3;
25112 int num12 = num7;
25113 int num13 = num8;
25114 bool flag = true;
25115 int num14 = 0;
25116 int num15 = 0;
25117 int num16 = -10;
25118 Rectangle rectangle = new Rectangle(num12 - num14 / 2, num13 - num15 / 2, num14, num15);
25119 while (flag)
25120 {
25121 num12 = num7;
25122 num13 = num8;
25123 num14 = genRand.Next(25, 50);
25124 num15 = genRand.Next(20, 35);
25125 if (num15 > num14)
25126 {
25127 num15 = num14;
25128 }
25129 if (i == num2 - 1)
25130 {
25131 num14 = genRand.Next(55, 65);
25132 num15 = genRand.Next(45, 50);
25133 if (num15 > num14)
25134 {
25135 num15 = num14;
25136 }
25137 num14 = (int)((double)num14 * 1.6);
25138 num15 = (int)((double)num15 * 1.35);
25139 num13 += genRand.Next(5, 10);
25140 }
25141 if (num10 > num9)
25142 {
25143 num13 += genRand.Next(num15 + 1, num15 + 3) + num16;
25144 num12 += genRand.Next(-5, 6);
25145 num11 = num3 * -1;
25146 }
25147 else
25148 {
25149 num12 += (genRand.Next(num14 + 1, num14 + 3) + num16) * num11;
25150 num13 += genRand.Next(-5, 6);
25151 }
25152 flag = false;
25153 rectangle = new Rectangle(num12 - num14 / 2, num13 - num15 / 2, num14, num15);
25154 for (int j = 0; j < i; j++)
25155 {
25156 if (rectangle.Intersects(array[j]))
25157 {
25158 flag = true;
25159 }
25160 if (genRand.Next(100) == 0)
25161 {
25162 num16++;
25163 }
25164 }
25165 }
25166 if (num10 > num9)
25167 {
25168 num9++;
25169 num10 = 1;
25170 }
25171 array[i] = rectangle;
25172 num3 = num11;
25173 num7 = num12;
25174 num8 = num13;
25175 }
25176 for (int k = 0; k < num2; k++)
25177 {
25178 for (int l = 0; l < 2; l++)
25179 {
25180 for (int m = 0; m < num2; m++)
25181 {
25182 for (int n = 0; n < 2; n++)
25183 {
25184 int num17 = array[k].X;
25185 if (l == 1)
25186 {
25187 num17 += array[k].Width - 1;
25188 }
25189 int num18 = array[k].Y;
25190 int num19 = num18 + array[k].Height;
25191 int num20 = array[m].X;
25192 if (n == 1)
25193 {
25194 num20 += array[m].Width - 1;
25195 }
25196 int y2 = array[m].Y;
25197 int num21 = y2 + array[m].Height;
25198 while (num17 != num20 || num18 != y2 || num19 != num21)
25199 {
25200 if (num17 < num20)
25201 {
25202 num17++;
25203 }
25204 if (num17 > num20)
25205 {
25206 num17--;
25207 }
25208 if (num18 < y2)
25209 {
25210 num18++;
25211 }
25212 if (num18 > y2)
25213 {
25214 num18--;
25215 }
25216 if (num19 < num21)
25217 {
25218 num19++;
25219 }
25220 if (num19 > num21)
25221 {
25222 num19--;
25223 }
25224 int num22 = num17;
25225 for (int num23 = num18; num23 < num19; num23++)
25226 {
25227 Main.tile[num22, num23].active(active: true);
25228 Main.tile[num22, num23].type = 226;
25229 Main.tile[num22, num23].liquid = 0;
25230 Main.tile[num22, num23].slope(0);
25231 Main.tile[num22, num23].halfBrick(halfBrick: false);
25232 }
25233 }
25234 }
25235 }
25236 }
25237 }
25238 for (int num24 = 0; num24 < num2; num24++)
25239 {
25240 if (false)
25241 {
25242 continue;
25243 }
25244 for (int num25 = array[num24].X; num25 < array[num24].X + array[num24].Width; num25++)
25245 {
25246 for (int num26 = array[num24].Y; num26 < array[num24].Y + array[num24].Height; num26++)
25247 {
25248 Main.tile[num25, num26].active(active: true);
25249 Main.tile[num25, num26].type = 226;
25250 Main.tile[num25, num26].liquid = 0;
25251 Main.tile[num25, num26].slope(0);
25252 Main.tile[num25, num26].halfBrick(halfBrick: false);
25253 }
25254 }
25255 int x2 = array[num24].X;
25256 int num27 = x2 + array[num24].Width;
25257 int y3 = array[num24].Y;
25258 int num28 = y3 + array[num24].Height;
25259 x2 += genRand.Next(3, 8);
25260 num27 -= genRand.Next(3, 8);
25261 y3 += genRand.Next(3, 8);
25262 num28 -= genRand.Next(3, 8);
25263 int num29 = x2;
25264 int num30 = num27;
25265 int num31 = y3;
25266 int num32 = num28;
25267 int num33 = (x2 + num27) / 2;
25268 int num34 = (y3 + num28) / 2;
25269 for (int num35 = x2; num35 < num27; num35++)
25270 {
25271 for (int num36 = y3; num36 < num28; num36++)
25272 {
25273 if (genRand.Next(20) == 0)
25274 {
25275 num31 += genRand.Next(-1, 2);
25276 }
25277 if (genRand.Next(20) == 0)
25278 {
25279 num32 += genRand.Next(-1, 2);
25280 }
25281 if (genRand.Next(20) == 0)
25282 {
25283 num29 += genRand.Next(-1, 2);
25284 }
25285 if (genRand.Next(20) == 0)
25286 {
25287 num30 += genRand.Next(-1, 2);
25288 }
25289 if (num29 < x2)
25290 {
25291 num29 = x2;
25292 }
25293 if (num30 > num27)
25294 {
25295 num30 = num27;
25296 }
25297 if (num31 < y3)
25298 {
25299 num31 = y3;
25300 }
25301 if (num32 > num28)
25302 {
25303 num32 = num28;
25304 }
25305 if (num29 > num33)
25306 {
25307 num29 = num33;
25308 }
25309 if (num30 < num33)
25310 {
25311 num30 = num33;
25312 }
25313 if (num31 > num34)
25314 {
25315 num31 = num34;
25316 }
25317 if (num32 < num34)
25318 {
25319 num32 = num34;
25320 }
25321 if (num35 >= num29 && num35 < num30 && num36 >= num31 && num36 <= num32)
25322 {
25323 Main.tile[num35, num36].active(active: false);
25324 Main.tile[num35, num36].wall = 87;
25325 }
25326 }
25327 }
25328 for (int num37 = num28; num37 > y3; num37--)
25329 {
25330 for (int num38 = num27; num38 > x2; num38--)
25331 {
25332 if (genRand.Next(20) == 0)
25333 {
25334 num31 += genRand.Next(-1, 2);
25335 }
25336 if (genRand.Next(20) == 0)
25337 {
25338 num32 += genRand.Next(-1, 2);
25339 }
25340 if (genRand.Next(20) == 0)
25341 {
25342 num29 += genRand.Next(-1, 2);
25343 }
25344 if (genRand.Next(20) == 0)
25345 {
25346 num30 += genRand.Next(-1, 2);
25347 }
25348 if (num29 < x2)
25349 {
25350 num29 = x2;
25351 }
25352 if (num30 > num27)
25353 {
25354 num30 = num27;
25355 }
25356 if (num31 < y3)
25357 {
25358 num31 = y3;
25359 }
25360 if (num32 > num28)
25361 {
25362 num32 = num28;
25363 }
25364 if (num29 > num33)
25365 {
25366 num29 = num33;
25367 }
25368 if (num30 < num33)
25369 {
25370 num30 = num33;
25371 }
25372 if (num31 > num34)
25373 {
25374 num31 = num34;
25375 }
25376 if (num32 < num34)
25377 {
25378 num32 = num34;
25379 }
25380 if (num38 >= num29 && num38 < num30 && num37 >= num31 && num37 <= num32)
25381 {
25382 Main.tile[num38, num37].active(active: false);
25383 Main.tile[num38, num37].wall = 87;
25384 }
25385 }
25386 }
25387 }
25388 Vector2D val = default(Vector2D);
25389 ((Vector2D)(ref val))._002Ector((double)num5, (double)num6);
25390 for (int num39 = 0; num39 < num2; num39++)
25391 {
25392 Rectangle rectangle2 = array[num39];
25393 rectangle2.X += 8;
25394 rectangle2.Y += 8;
25395 rectangle2.Width -= 16;
25396 rectangle2.Height -= 16;
25397 bool flag2 = true;
25398 while (flag2)
25399 {
25400 int num40 = genRand.Next(rectangle2.X, rectangle2.X + rectangle2.Width);
25401 int num41 = genRand.Next(rectangle2.Y, rectangle2.Y + rectangle2.Height);
25402 if (num39 == num2 - 1)
25403 {
25404 num40 = rectangle2.X + rectangle2.Width / 2 + genRand.Next(-10, 10);
25405 num41 = rectangle2.Y + rectangle2.Height / 2 + genRand.Next(-10, 10);
25406 }
25407 val = templePather(val, num40, num41);
25408 if (val.X == (double)num40 && val.Y == (double)num41)
25409 {
25410 flag2 = false;
25411 }
25412 }
25413 if (num39 >= num2 - 1)
25414 {
25415 continue;
25416 }
25417 if (genRand.Next(3) != 0)
25418 {
25419 int num42 = num39 + 1;
25420 if (array[num42].Y >= array[num39].Y + array[num39].Height)
25421 {
25422 rectangle2.X = array[num42].X;
25423 if (num39 == 0)
25424 {
25425 if (num3 > 0)
25426 {
25427 rectangle2.X += (int)((double)array[num42].Width * 0.8);
25428 }
25429 else
25430 {
25431 rectangle2.X += (int)((double)array[num42].Width * 0.2);
25432 }
25433 }
25434 else if (array[num42].X < array[num39].X)
25435 {
25436 rectangle2.X += (int)((double)array[num42].Width * 0.2);
25437 }
25438 else
25439 {
25440 rectangle2.X += (int)((double)array[num42].Width * 0.8);
25441 }
25442 rectangle2.Y = array[num42].Y;
25443 }
25444 else
25445 {
25446 rectangle2.X = (array[num39].X + array[num39].Width / 2 + array[num42].X + array[num42].Width / 2) / 2;
25447 rectangle2.Y = (int)((double)array[num42].Y + (double)array[num42].Height * 0.8);
25448 }
25449 int x3 = rectangle2.X;
25450 int y4 = rectangle2.Y;
25451 flag2 = true;
25452 while (flag2)
25453 {
25454 int num43 = genRand.Next(x3 - 6, x3 + 7);
25455 int num44 = genRand.Next(y4 - 6, y4 + 7);
25456 val = templePather(val, num43, num44);
25457 if (val.X == (double)num43 && val.Y == (double)num44)
25458 {
25459 flag2 = false;
25460 }
25461 }
25462 continue;
25463 }
25464 int num45 = num39 + 1;
25465 int num46 = (array[num39].X + array[num39].Width / 2 + array[num45].X + array[num45].Width / 2) / 2;
25466 int num47 = (array[num39].Y + array[num39].Height / 2 + array[num45].Y + array[num45].Height / 2) / 2;
25467 flag2 = true;
25468 while (flag2)
25469 {
25470 int num48 = genRand.Next(num46 - 6, num46 + 7);
25471 int num49 = genRand.Next(num47 - 6, num47 + 7);
25472 val = templePather(val, num48, num49);
25473 if (val.X == (double)num48 && val.Y == (double)num49)
25474 {
25475 flag2 = false;
25476 }
25477 }
25478 }
25479 int num50 = Main.maxTilesX - 20;
25480 int num51 = 20;
25481 int num52 = Main.maxTilesY - 20;
25482 int num53 = 20;
25483 for (int num54 = 0; num54 < num2; num54++)
25484 {
25485 if (array[num54].X < num50)
25486 {
25487 num50 = array[num54].X;
25488 }
25489 if (array[num54].X + array[num54].Width > num51)
25490 {
25491 num51 = array[num54].X + array[num54].Width;
25492 }
25493 if (array[num54].Y < num52)
25494 {
25495 num52 = array[num54].Y;
25496 }
25497 if (array[num54].Y + array[num54].Height > num53)
25498 {
25499 num53 = array[num54].Y + array[num54].Height;
25500 }
25501 }
25502 num50 -= 10;
25503 num51 += 10;
25504 num52 -= 10;
25505 num53 += 10;
25506 for (int num55 = num50; num55 < num51; num55++)
25507 {
25508 for (int num56 = num52; num56 < num53; num56++)
25509 {
25510 outerTempled(num55, num56);
25511 }
25512 }
25513 for (int num57 = num51; num57 >= num50; num57--)
25514 {
25515 for (int num58 = num52; num58 < num53 / 2; num58++)
25516 {
25517 outerTempled(num57, num58);
25518 }
25519 }
25520 for (int num59 = num52; num59 < num53; num59++)
25521 {
25522 for (int num60 = num50; num60 < num51; num60++)
25523 {
25524 outerTempled(num60, num59);
25525 }
25526 }
25527 for (int num61 = num53; num61 >= num52; num61--)
25528 {
25529 for (int num62 = num50; num62 < num51; num62++)
25530 {
25531 outerTempled(num62, num61);
25532 }
25533 }
25534 int num63 = num6;
25535 num3 = -num4;
25536 Vector2D val2 = default(Vector2D);
25537 ((Vector2D)(ref val2))._002Ector((double)num5, (double)num6);
25538 int num64 = genRand.Next(2, 5);
25539 bool flag3 = true;
25540 int num65 = 0;
25541 int num66 = genRand.Next(9, 14);
25542 while (flag3)
25543 {
25544 num65++;
25545 if (num65 >= num66)
25546 {
25547 num65 = 0;
25548 val2.Y -= 1.0;
25549 }
25550 val2.X += num3;
25551 int num67 = (int)val2.X;
25552 flag3 = false;
25553 for (int num68 = (int)val2.Y - num64; (double)num68 < val2.Y + (double)num64; num68++)
25554 {
25555 if (Main.tile[num67, num68].wall == 87 || (Main.tile[num67, num68].active() && Main.tile[num67, num68].type == 226))
25556 {
25557 flag3 = true;
25558 }
25559 if (Main.tile[num67, num68].active() && Main.tile[num67, num68].type == 226)
25560 {
25561 if (num68 > num63)
25562 {
25563 num63 = num68;
25564 }
25565 Main.tile[num67, num68].active(active: false);
25566 Main.tile[num67, num68].wall = 87;
25567 }
25568 }
25569 }
25570 num63 += 2;
25571 int num69 = num5;
25572 int num70 = num6;
25573 while (!Main.tile[num69, num70].active())
25574 {
25575 num70++;
25576 if (num70 >= num63)
25577 {
25578 num70 = num63;
25579 Main.tile[num69, num70].ClearEverything();
25580 Main.tile[num69, num70].active(active: true);
25581 Main.tile[num69, num70].type = 226;
25582 break;
25583 }
25584 }
25585 num70 -= 4;
25586 int num71 = num70;
25587 while ((Main.tile[num69, num71].active() && Main.tile[num69, num71].type == 226) || Main.tile[num69, num71].wall == 87)
25588 {
25589 num71--;
25590 }
25591 num71 += 2;
25592 for (int num72 = num69 - 1; num72 <= num69 + 1; num72++)
25593 {
25594 for (int num73 = num71; num73 <= num70; num73++)
25595 {
25596 Main.tile[num72, num73].active(active: true);
25597 Main.tile[num72, num73].type = 226;
25598 Main.tile[num72, num73].liquid = 0;
25599 Main.tile[num72, num73].slope(0);
25600 Main.tile[num72, num73].halfBrick(halfBrick: false);
25601 }
25602 }
25603 for (int num74 = num69 - 4; num74 <= num69 + 4; num74++)
25604 {
25605 for (int num75 = num70 - 1; num75 < num70 + 3; num75++)
25606 {
25607 Main.tile[num74, num75].active(active: false);
25608 Main.tile[num74, num75].wall = 87;
25609 }
25610 }
25611 for (int num76 = num69 - 1; num76 <= num69 + 1; num76++)
25612 {
25613 for (int num77 = num70 - 5; num77 <= num70 + 8; num77++)
25614 {
25615 Main.tile[num76, num77].active(active: true);
25616 Main.tile[num76, num77].type = 226;
25617 Main.tile[num76, num77].liquid = 0;
25618 Main.tile[num76, num77].slope(0);
25619 Main.tile[num76, num77].halfBrick(halfBrick: false);
25620 }
25621 }
25622 for (int num78 = num69 - 3; num78 <= num69 + 3; num78++)
25623 {
25624 for (int num79 = num70 - 2; num79 < num70 + 3; num79++)
25625 {
25626 if (num79 >= num70 || num78 < num5 - 1 || num78 > num5 + 1)
25627 {
25628 Main.tile[num78, num79].active(active: false);
25629 Main.tile[num78, num79].wall = 87;
25630 }
25631 }
25632 }
25633 PlaceTile(num69, num70, 10, mute: true, forced: false, -1, 11);
25634 for (int num80 = num50; num80 < num51; num80++)
25635 {
25636 for (int num81 = num52; num81 < num53; num81++)
25637 {
25638 templeCleaner(num80, num81);
25639 }
25640 }
25641 for (int num82 = num53; num82 >= num52; num82--)
25642 {
25643 for (int num83 = num51; num83 >= num50; num83--)
25644 {
25645 templeCleaner(num83, num82);
25646 }
25647 }
25648 for (int num84 = num50; num84 < num51; num84++)
25649 {
25650 for (int num85 = num52; num85 < num53; num85++)
25651 {
25652 bool flag4 = true;
25653 for (int num86 = num84 - 1; num86 <= num84 + 1; num86++)
25654 {
25655 for (int num87 = num85 - 1; num87 <= num85 + 1; num87++)
25656 {
25657 if ((!Main.tile[num86, num87].active() || Main.tile[num86, num87].type != 226) && Main.tile[num86, num87].wall != 87)
25658 {
25659 flag4 = false;
25660 break;
25661 }
25662 }
25663 }
25664 if (flag4)
25665 {
25666 Main.tile[num84, num85].wall = 87;
25667 }
25668 }
25669 }
25670 int num88 = 0;
25671 Rectangle rectangle3 = array[num2 - 1];
25672 int num89 = rectangle3.Width / 2;
25673 int num90 = rectangle3.Height / 2;
25674 while (true)
25675 {
25676 num88++;
25677 int num91 = rectangle3.X + num89 + 15 - genRand.Next(30);
25678 int num92 = rectangle3.Y + num90 + 15 - genRand.Next(30);
25679 PlaceTile(num91, num92, 237);
25680 if (Main.tile[num91, num92].type == 237)
25681 {
25682 GenVars.lAltarX = num91 - Main.tile[num91, num92].frameX / 18;
25683 GenVars.lAltarY = num92 - Main.tile[num91, num92].frameY / 18;
25684 break;
25685 }
25686 if (num88 < 1000)
25687 {
25688 continue;
25689 }
25690 num91 = rectangle3.X + num89;
25691 num92 = rectangle3.Y + num90;
25692 num91 += genRand.Next(-10, 11);
25693 for (num92 += genRand.Next(-10, 11); !Main.tile[num91, num92].active(); num92++)
25694 {
25695 }
25696 Main.tile[num91 - 1, num92].active(active: true);
25697 Main.tile[num91 - 1, num92].slope(0);
25698 Main.tile[num91 - 1, num92].halfBrick(halfBrick: false);
25699 Main.tile[num91 - 1, num92].type = 226;
25700 Main.tile[num91, num92].active(active: true);
25701 Main.tile[num91, num92].slope(0);
25702 Main.tile[num91, num92].halfBrick(halfBrick: false);
25703 Main.tile[num91, num92].type = 226;
25704 Main.tile[num91 + 1, num92].active(active: true);
25705 Main.tile[num91 + 1, num92].slope(0);
25706 Main.tile[num91 + 1, num92].halfBrick(halfBrick: false);
25707 Main.tile[num91 + 1, num92].type = 226;
25708 num92 -= 2;
25709 num91--;
25710 for (int num93 = -1; num93 <= 3; num93++)
25711 {
25712 for (int num94 = -1; num94 <= 1; num94++)
25713 {
25714 x = num91 + num93;
25715 y = num92 + num94;
25716 Main.tile[x, y].active(active: false);
25717 }
25718 }
25719 GenVars.lAltarX = num91;
25720 GenVars.lAltarY = num92;
25721 for (int num95 = 0; num95 <= 2; num95++)
25722 {
25723 for (int num96 = 0; num96 <= 1; num96++)
25724 {
25725 x = num91 + num95;
25726 y = num92 + num96;
25727 Main.tile[x, y].active(active: true);
25728 Main.tile[x, y].type = 237;
25729 Main.tile[x, y].frameX = (short)(num95 * 18);
25730 Main.tile[x, y].frameY = (short)(num96 * 18);
25731 }
25732 }
25733 for (int num97 = 0; num97 <= 2; num97++)
25734 {
25735 for (int num98 = 0; num98 <= 1; num98++)
25736 {
25737 x = num91 + num97;
25738 y = num92 + num98;
25739 SquareTileFrame(x, y);
25740 }
25741 }
25742 break;
25743 }
25744 double num99 = (double)num2 * 1.1;
25745 num99 *= 1.0 + (double)genRand.Next(-25, 26) * 0.01;
25746 if (drunkWorldGen)
25747 {
25748 num99 *= 1.5;
25749 }
25750 int num100 = 0;
25751 while (num99 > 0.0)
25752 {
25753 num100++;
25754 int num101 = genRand.Next(num2);
25755 int num102 = genRand.Next(array[num101].X, array[num101].X + array[num101].Width);
25756 int num103 = genRand.Next(array[num101].Y, array[num101].Y + array[num101].Height);
25757 if (Main.tile[num102, num103].wall == 87 && !Main.tile[num102, num103].active())
25758 {
25759 bool flag5 = false;
25760 if (genRand.Next(2) == 0)
25761 {
25762 int num104 = 1;
25763 if (genRand.Next(2) == 0)
25764 {
25765 num104 = -1;
25766 }
25767 for (; !Main.tile[num102, num103].active(); num103 += num104)
25768 {
25769 }
25770 num103 -= num104;
25771 int num105 = genRand.Next(2);
25772 int num106 = genRand.Next(3, 10);
25773 bool flag6 = true;
25774 for (int num107 = num102 - num106; num107 < num102 + num106; num107++)
25775 {
25776 for (int num108 = num103 - num106; num108 < num103 + num106; num108++)
25777 {
25778 if (Main.tile[num107, num108].active() && (Main.tile[num107, num108].type == 10 || Main.tile[num107, num108].type == 237))
25779 {
25780 flag6 = false;
25781 break;
25782 }
25783 }
25784 }
25785 if (flag6)
25786 {
25787 for (int num109 = num102 - num106; num109 < num102 + num106; num109++)
25788 {
25789 for (int num110 = num103 - num106; num110 < num103 + num106; num110++)
25790 {
25791 if (!SolidTile(num109, num110) || Main.tile[num109, num110].type == 232 || SolidTile(num109, num110 - num104))
25792 {
25793 continue;
25794 }
25795 Main.tile[num109, num110].type = 232;
25796 flag5 = true;
25797 if (num105 == 0)
25798 {
25799 Main.tile[num109, num110 - 1].type = 232;
25800 Main.tile[num109, num110 - 1].active(active: true);
25801 if (drunkWorldGen)
25802 {
25803 Main.tile[num109, num110 - 2].type = 232;
25804 Main.tile[num109, num110 - 2].active(active: true);
25805 }
25806 }
25807 else
25808 {
25809 Main.tile[num109, num110 + 1].type = 232;
25810 Main.tile[num109, num110 + 1].active(active: true);
25811 if (drunkWorldGen)
25812 {
25813 Main.tile[num109, num110 + 2].type = 232;
25814 Main.tile[num109, num110 + 2].active(active: true);
25815 }
25816 }
25817 num105++;
25818 if (num105 > 1)
25819 {
25820 num105 = 0;
25821 }
25822 }
25823 }
25824 }
25825 if (flag5)
25826 {
25827 num100 = 0;
25828 num99 -= 1.0;
25829 }
25830 }
25831 else
25832 {
25833 int num111 = 1;
25834 if (genRand.Next(2) == 0)
25835 {
25836 num111 = -1;
25837 }
25838 for (; !Main.tile[num102, num103].active(); num102 += num111)
25839 {
25840 }
25841 num102 -= num111;
25842 int num112 = genRand.Next(2);
25843 int num113 = genRand.Next(3, 10);
25844 bool flag7 = true;
25845 for (int num114 = num102 - num113; num114 < num102 + num113; num114++)
25846 {
25847 for (int num115 = num103 - num113; num115 < num103 + num113; num115++)
25848 {
25849 if (Main.tile[num114, num115].active() && Main.tile[num114, num115].type == 10)
25850 {
25851 flag7 = false;
25852 break;
25853 }
25854 }
25855 }
25856 if (flag7)
25857 {
25858 for (int num116 = num102 - num113; num116 < num102 + num113; num116++)
25859 {
25860 for (int num117 = num103 - num113; num117 < num103 + num113; num117++)
25861 {
25862 if (!SolidTile(num116, num117) || Main.tile[num116, num117].type == 232 || SolidTile(num116 - num111, num117))
25863 {
25864 continue;
25865 }
25866 Main.tile[num116, num117].type = 232;
25867 flag5 = true;
25868 if (num112 == 0)
25869 {
25870 Main.tile[num116 - 1, num117].type = 232;
25871 Main.tile[num116 - 1, num117].active(active: true);
25872 if (drunkWorldGen)
25873 {
25874 Main.tile[num116 - 2, num117].type = 232;
25875 Main.tile[num116 - 2, num117].active(active: true);
25876 }
25877 }
25878 else
25879 {
25880 Main.tile[num116 + 1, num117].type = 232;
25881 Main.tile[num116 + 1, num117].active(active: true);
25882 if (drunkWorldGen)
25883 {
25884 Main.tile[num116 - 2, num117].type = 232;
25885 Main.tile[num116 - 2, num117].active(active: true);
25886 }
25887 }
25888 num112++;
25889 if (num112 > 1)
25890 {
25891 num112 = 0;
25892 }
25893 }
25894 }
25895 }
25896 if (flag5)
25897 {
25898 num100 = 0;
25899 num99 -= 1.0;
25900 }
25901 }
25902 }
25903 if (num100 > 1000)
25904 {
25905 num100 = 0;
25906 num99 -= 1.0;
25907 }
25908 }
25909 GenVars.tLeft = num50;
25910 GenVars.tRight = num51;
25911 GenVars.tTop = num52;
25912 GenVars.tBottom = num53;
25913 GenVars.tRooms = num2;
25914 }
Terraria.WorldGen.templeCleaner
static void templeCleaner(int x, int y)
Definition WorldGen.cs:24958
Terraria.WorldGen.remixWorldGen
static bool remixWorldGen
Definition WorldGen.cs:1148
Terraria.WorldGen.templePather
static Vector2D templePather(Vector2D templePath, int destX, int destY)
Definition WorldGen.cs:24995
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.outerTempled
static void outerTempled(int x, int y)
Definition WorldGen.cs:25035
Terraria.WorldGen.drunkWorldGen
static bool drunkWorldGen
Definition WorldGen.cs:1154
Terraria.WorldGen.SquareTileFrame
static void SquareTileFrame(int i, int j, bool resetFrame=true)
Definition WorldGen.cs:70362
Terraria.WorldGen.getGoodWorldGen
static bool getGoodWorldGen
Definition WorldGen.cs:1156

References System.array, Terraria.Main.maxTilesX, Terraria.Enums.SolidTile, Terraria.Main.tile, ReLogic.Utilities.Vector2D.X, System.X, ReLogic.Utilities.Vector2D.Y, and System.Y.