71432 {
71434 try
71435 {
71436 if (i > 5 &&
j > 5 && i < Main.maxTilesX - 5 &&
j < Main.maxTilesY - 5 && Main.tile[i,
j] !=
null)
71437 {
71439 {
71440 return;
71441 }
71443 Tile tile = Main.tile[
i,
j];
71444 if (!tile.active())
71445 {
71446 tile.halfBrick(halfBrick:
false);
71447 tile.ClearBlockPaintAndCoating();
71448 tile.slope(0);
71449 }
71450 if (tile.liquid > 0 && Main.netMode != 1 && !
noLiquidCheck)
71451 {
71452 Liquid.AddWater(i,
j);
71453 }
71454 if (tile.active())
71455 {
71456 if (
noBreak && Main.tileFrameImportant[tile.type] && tile.type != 4)
71457 {
71458 return;
71459 }
71460 int num = tile.type;
71461 if (Main.tileStone[num])
71462 {
71463 num = 1;
71464 }
71465 int frameX = tile.frameX;
71466 int frameY = tile.frameY;
71468 if (Main.tileFrameImportant[tile.type])
71469 {
71470 switch (num)
71471 {
71472 case 518:
71474 break;
71475 case 519:
71477 break;
71478 case 549:
71480 break;
71481 case 571:
71483 break;
71484 case 4:
71486 break;
71487 case 442:
71489 break;
71490 case 136:
71491 {
71508 {
71510 }
71512 {
71514 }
71516 {
71518 }
71520 {
71522 }
71524 {
71526 }
71528 {
71530 }
71532 {
71534 }
71536 {
71538 }
71540 {
71541 tile.frameX = 0;
71542 }
71544 {
71545 tile.frameX = 18;
71546 }
71548 {
71549 tile.frameX = 36;
71550 }
71551 else if (tile.wall > 0)
71552 {
71553 tile.frameX = 54;
71554 }
71555 else
71556 {
71558 }
71559 break;
71560 }
71561 case 129:
71562 case 149:
71563 {
71573 {
71575 }
71577 {
71579 }
71581 {
71583 }
71585 {
71587 }
71588 if (
num23 >= 0 && Main.tileSolid[
num23] && !Main.tileSolidTop[
num23])
71589 {
71590 tile.frameY = 0;
71591 }
71592 else if (
num25 >= 0 && Main.tileSolid[
num25] && !Main.tileSolidTop[
num25])
71593 {
71594 tile.frameY = 54;
71595 }
71596 else if (
num26 >= 0 && Main.tileSolid[
num26] && !Main.tileSolidTop[
num26])
71597 {
71598 tile.frameY = 36;
71599 }
71600 else if (
num24 >= 0 && Main.tileSolid[
num24] && !Main.tileSolidTop[
num24])
71601 {
71602 tile.frameY = 18;
71603 }
71604 else
71605 {
71607 }
71608 break;
71609 }
71610 default:
71611 if (num != 461)
71612 {
71613 switch (num)
71614 {
71615 case 178:
71616 {
71626 {
71628 }
71630 {
71632 }
71634 {
71636 }
71638 {
71640 }
71642 {
71644 }
71646 {
71648 }
71650 if (
num15 >= 0 && Main.tileSolid[
num15] && !Main.tileSolidTop[
num15])
71651 {
71652 if (tile.frameY < 0 || tile.frameY > 36)
71653 {
71654 tile.frameY =
num19;
71655 }
71656 }
71657 else if (
num17 >= 0 && Main.tileSolid[
num17] && !Main.tileSolidTop[
num17])
71658 {
71659 if (tile.frameY < 108 || tile.frameY > 54)
71660 {
71662 }
71663 }
71664 else if (
num18 >= 0 && Main.tileSolid[
num18] && !Main.tileSolidTop[
num18])
71665 {
71666 if (tile.frameY < 162 || tile.frameY > 198)
71667 {
71669 }
71670 }
71671 else if (
num16 >= 0 && Main.tileSolid[
num16] && !Main.tileSolidTop[
num16])
71672 {
71673 if (tile.frameY < 54 || tile.frameY > 90)
71674 {
71676 }
71677 }
71678 else
71679 {
71681 }
71682 break;
71683 }
71684 case 184:
71685 {
71695 {
71697 }
71699 {
71701 }
71703 {
71705 }
71707 {
71709 }
71712 {
71714 if (tile.frameY < 0 || tile.frameY > 36)
71715 {
71716 tile.frameY =
num14;
71717 }
71718 }
71720 {
71722 if (tile.frameY < 54 || tile.frameY > 90)
71723 {
71725 }
71726 }
71728 {
71730 if (tile.frameY < 108 || tile.frameY > 144)
71731 {
71733 }
71734 }
71736 {
71738 if (tile.frameY < 162 || tile.frameY > 198)
71739 {
71741 }
71742 }
71743 else
71744 {
71746 }
71747 break;
71748 }
71749 case 529:
71750 {
71752 {
71754 break;
71755 }
71757 _ = Main.tile[
i,
j].frameY / 34;
71759 {
71761 }
71762 break;
71763 }
71764 case 3:
71765 case 24:
71766 case 61:
71767 case 71:
71768 case 73:
71769 case 74:
71770 case 110:
71771 case 113:
71772 case 201:
71773 case 637:
71775 break;
71776 case 227:
71778 break;
71779 case 579:
71781 break;
71782 case 12:
71783 case 31:
71784 case 639:
71786 break;
71787 case 165:
71789 break;
71790 case 324:
71792 {
71794 }
71795 break;
71796 case 235:
71798 break;
71799 case 185:
71801 break;
71802 default:
71803 if (num != 296 && num != 297 && num != 309 && num != 358 && num != 359 && num != 413 && num != 414 && num != 542 && num != 550 && num != 551 && num != 553 && num != 554 && num != 558 && num != 559 && num != 599 && num != 600 && num != 601 && num != 602 && num != 603 && num != 604 && num != 605 && num != 606 && num != 607 && num != 608 && num != 609 && num != 610 && num != 611 && num != 612 && num != 632 && num != 640 && num != 643 && num != 644 && num != 645)
71804 {
71805 if (num == 10)
71806 {
71808 break;
71809 }
71810 if (num == 11)
71811 {
71813 break;
71814 }
71815 if (num == 314)
71816 {
71821 {
71823 }
71825 {
71827 }
71828 break;
71829 }
71830 if (num == 380)
71831 {
71834 {
71835 break;
71836 }
71839 {
71840 break;
71841 }
71844 {
71845 break;
71846 }
71849 {
71850 break;
71851 }
71854 {
71855 break;
71856 }
71859 {
71863 {
71865 }
71867 {
71869 }
71870 if (
num2 >= 0 && !Main.tileSolid[
num2])
71871 {
71873 }
71874 if (
num3 >= 0 && !Main.tileSolid[
num3])
71875 {
71877 }
71879 {
71880 rectangle.X = 18;
71881 }
71882 else if (
num3 == num &&
num2 != num)
71883 {
71884 rectangle.X = 36;
71885 }
71886 else if (
num3 != num &&
num2 == num)
71887 {
71888 rectangle.X = 0;
71889 }
71890 else
71891 {
71892 rectangle.X = 54;
71893 }
71895 }
71896 break;
71897 }
71899 {
71902 {
71903 break;
71904 }
71907 {
71908 break;
71909 }
71912 {
71913 break;
71914 }
71917 {
71918 break;
71919 }
71922 {
71923 break;
71924 }
71927 {
71928 break;
71929 }
71933 {
71935 }
71937 {
71939 }
71940 if (
num4 >= 0 && !Main.tileSolid[
num4])
71941 {
71943 }
71944 if (
num5 >= 0 && !Main.tileSolid[
num5])
71945 {
71947 }
71948 if (
num5 == num &&
tile4.halfBrick() != tile.halfBrick())
71949 {
71951 }
71952 if (
num4 == num &&
tile5.halfBrick() != tile.halfBrick())
71953 {
71955 }
71956 if (
num5 != -1 &&
num5 != num && tile.halfBrick())
71957 {
71959 }
71960 if (
num4 != -1 &&
num4 != num && tile.halfBrick())
71961 {
71963 }
71965 {
71967 }
71969 {
71971 }
71973 {
71975 }
71977 {
71979 }
71980 if (tile.slope() == 1)
71981 {
71983 {
71984 rectangle.X = 468;
71985 }
71987 {
71989 {
71990 rectangle.X = 432;
71991 }
71992 else
71993 {
71994 rectangle.X = 360;
71995 }
71996 }
71998 {
71999 rectangle.X = 396;
72000 }
72001 else
72002 {
72003 rectangle.X = 180;
72004 }
72005 }
72006 else if (tile.slope() == 2)
72007 {
72009 {
72010 rectangle.X = 450;
72011 }
72013 {
72015 {
72016 rectangle.X = 414;
72017 }
72018 else
72019 {
72020 rectangle.X = 342;
72021 }
72022 }
72024 {
72025 rectangle.X = 378;
72026 }
72027 else
72028 {
72029 rectangle.X = 144;
72030 }
72031 }
72032 else if (
num5 == num &&
num4 == num)
72033 {
72034 if (
tile4.slope() == 2 &&
tile5.slope() == 1)
72035 {
72036 rectangle.X = 252;
72037 }
72038 else if (
tile4.slope() == 2)
72039 {
72040 rectangle.X = 216;
72041 }
72042 else if (
tile5.slope() == 1)
72043 {
72044 rectangle.X = 234;
72045 }
72046 else
72047 {
72048 rectangle.X = 0;
72049 }
72050 }
72051 else if (
num5 == num &&
num4 == -1)
72052 {
72053 if (
tile4.slope() == 2)
72054 {
72055 rectangle.X = 270;
72056 }
72057 else
72058 {
72059 rectangle.X = 18;
72060 }
72061 }
72062 else if (
num5 == -1 &&
num4 == num)
72063 {
72064 if (
tile5.slope() == 1)
72065 {
72066 rectangle.X = 288;
72067 }
72068 else
72069 {
72070 rectangle.X = 36;
72071 }
72072 }
72073 else if (
num5 != num &&
num4 == num)
72074 {
72075 rectangle.X = 54;
72076 }
72077 else if (
num5 == num &&
num4 != num)
72078 {
72079 rectangle.X = 72;
72080 }
72082 {
72083 rectangle.X = 108;
72084 }
72086 {
72087 rectangle.X = 126;
72088 }
72089 else
72090 {
72091 rectangle.X = 90;
72092 }
72094 if (Main.tile[i,
j - 1] !=
null && Main.tileRope[Main.tile[i,
j - 1].type])
72095 {
72097 }
72098 if (Main.tile[i,
j + 1] !=
null && Main.tileRope[Main.tile[i,
j + 1].type])
72099 {
72101 }
72102 break;
72103 }
72104 switch (num)
72105 {
72106 case 233:
72107 case 236:
72108 case 238:
72110 break;
72111 case 530:
72113 break;
72114 case 240:
72115 case 440:
72117 break;
72118 case 245:
72120 break;
72121 case 246:
72123 break;
72124 case 241:
72126 break;
72127 case 242:
72129 break;
72130 case 464:
72131 case 466:
72133 break;
72134 case 334:
72136 break;
72137 case 471:
72139 break;
72140 case 34:
72141 case 454:
72143 break;
72144 case 547:
72145 case 623:
72147 break;
72148 case 548:
72149 case 614:
72151 break;
72152 case 613:
72154 break;
72155 default:
72156 if (num != 354 && num != 406 && num != 412 && num != 355 && num != 452 && num != 455 && num != 491 && num != 499 && num != 642)
72157 {
72158 switch (num)
72159 {
72160 case 15:
72161 case 20:
72162 case 216:
72163 case 338:
72164 case 390:
72165 case 493:
72166 case 497:
72167 case 590:
72168 case 595:
72169 case 615:
72171 break;
72172 default:
72174 {
72175 switch (num)
72176 {
72177 case 405:
72178 case 486:
72179 case 488:
72180 case 532:
72181 case 533:
72182 case 544:
72183 case 552:
72184 case 555:
72185 case 556:
72186 case 582:
72187 case 619:
72188 case 629:
72189 case 647:
72190 case 648:
72191 case 651:
72192 break;
72193 case 36:
72194 case 135:
72195 case 141:
72196 case 144:
72197 case 210:
72198 case 239:
72199 case 428:
72200 case 593:
72201 case 624:
72202 case 650:
72203 case 656:
72205 return;
72206 case 476:
72208 return;
72209 case 494:
72211 return;
72212 case 419:
72213 case 420:
72214 case 423:
72215 case 424:
72216 case 429:
72217 case 445:
72219 return;
72220 case 16:
72221 case 18:
72222 case 29:
72223 case 103:
72224 case 134:
72225 case 462:
72226 case 649:
72228 return;
72229 case 13:
72230 case 33:
72231 case 49:
72232 case 50:
72233 case 78:
72234 case 174:
72235 case 372:
72236 case 646:
72238 return;
72239 default:
72241 {
72243 return;
72244 }
72245 switch (num)
72246 {
72247 case 128:
72249 break;
72250 case 269:
72252 break;
72253 case 470:
72255 break;
72256 case 475:
72258 break;
72259 case 597:
72261 break;
72262 case 27:
72264 break;
72265 case 28:
72266 case 653:
72268 break;
72269 case 171:
72271 break;
72272 default:
72274 {
72275 switch (num)
72276 {
72277 case 335:
72278 case 411:
72279 case 490:
72280 case 564:
72281 case 565:
72282 case 594:
72284 break;
72285 default:
72287 {
72288 switch (num)
72289 {
72290 case 172:
72291 case 360:
72292 case 505:
72293 case 521:
72294 case 522:
72295 case 523:
72296 case 524:
72297 case 525:
72298 case 526:
72299 case 527:
72300 case 543:
72301 case 568:
72302 case 569:
72303 case 570:
72304 case 580:
72305 case 598:
72306 case 620:
72307 case 652:
72308 case 654:
72309 break;
72310 case 376:
72311 case 443:
72312 case 444:
72313 case 485:
72315 return;
72316 case 91:
72318 return;
72319 case 35:
72320 case 139:
72322 return;
72323 case 386:
72324 case 387:
72326 return;
72327 case 388:
72328 case 389:
72330 return;
72331 case 92:
72332 case 93:
72333 case 453:
72335 return;
72336 case 104:
72337 case 105:
72338 case 207:
72339 case 320:
72340 case 337:
72341 case 349:
72342 case 356:
72343 case 378:
72344 case 410:
72345 case 456:
72346 case 465:
72347 case 480:
72348 case 489:
72349 case 506:
72350 case 509:
72351 case 531:
72352 case 545:
72353 case 560:
72354 case 591:
72355 case 592:
72356 case 657:
72357 case 658:
72358 case 663:
72360 return;
72361 case 101:
72362 case 102:
72363 case 463:
72364 case 617:
72366 return;
72367 case 42:
72368 case 270:
72369 case 271:
72370 case 572:
72371 case 581:
72372 case 660:
72374 return;
72375 case 55:
72376 case 85:
72377 case 395:
72378 case 425:
72379 case 510:
72380 case 511:
72381 case 573:
72383 return;
72384 case 520:
72386 return;
72387 case 209:
72389 return;
72390 case 79:
72391 case 90:
72392 case 487:
72394 return;
72395 case 94:
72396 case 95:
72397 case 97:
72398 case 98:
72399 case 99:
72400 case 100:
72401 case 125:
72402 case 126:
72403 case 173:
72404 case 282:
72405 case 287:
72406 case 319:
72407 case 621:
72408 case 622:
72410 return;
72411 case 96:
72413 return;
72414 case 81:
72415 {
72423 {
72425 }
72427 {
72429 }
72431 {
72433 }
72435 {
72437 }
72438 return;
72439 }
72440 default:
72441 if (Main.tileAlch[num])
72442 {
72444 return;
72445 }
72446 switch (num)
72447 {
72448 case 72:
72449 {
72455 {
72457 }
72459 {
72461 }
72463 {
72465 }
72466 else if (
num7 != num && tile.frameX == 0)
72467 {
72468 tile.frameNumber((
byte)
genRand.Next(3));
72469 if (tile.frameNumber() == 0)
72470 {
72471 tile.frameX = 18;
72472 tile.frameY = 0;
72473 }
72474 if (tile.frameNumber() == 1)
72475 {
72476 tile.frameX = 18;
72477 tile.frameY = 18;
72478 }
72479 if (tile.frameNumber() == 2)
72480 {
72481 tile.frameX = 18;
72482 tile.frameY = 36;
72483 }
72484 }
72485 break;
72486 }
72487 case 5:
72489 break;
72490 case 583:
72491 case 584:
72492 case 585:
72493 case 586:
72494 case 587:
72495 case 588:
72496 case 589:
72498 {
72500 });
72501 break;
72502 case 596:
72504 {
72506 });
72507 break;
72508 case 616:
72510 {
72512 });
72513 break;
72514 case 634:
72516 {
72518 });
72519 break;
72520 case 323:
72522 break;
72523 case 567:
72525 break;
72526 case 630:
72527 case 631:
72529 break;
72530 }
72531 return;
72532 }
72533 }
72534 goto case 132;
72535 case 132:
72536 case 138:
72537 case 142:
72538 case 143:
72539 case 288:
72540 case 289:
72541 case 290:
72542 case 291:
72543 case 292:
72544 case 293:
72545 case 294:
72546 case 295:
72547 case 484:
72548 case 664:
72549 case 665:
72551 break;
72552 }
72553 break;
72554 }
72555 goto case 254;
72556 case 254:
72558 break;
72559 }
72560 return;
72561 }
72562 }
72563 goto case 14;
72564 case 14:
72565 case 17:
72566 case 26:
72567 case 77:
72568 case 86:
72569 case 87:
72570 case 88:
72571 case 89:
72572 case 114:
72573 case 133:
72574 case 186:
72575 case 187:
72576 case 215:
72577 case 217:
72578 case 218:
72579 case 237:
72580 case 244:
72581 case 285:
72582 case 286:
72583 case 298:
72584 case 299:
72585 case 310:
72586 case 339:
72587 case 361:
72588 case 362:
72589 case 363:
72590 case 364:
72591 case 377:
72592 case 469:
72593 case 538:
72595 break;
72596 }
72597 break;
72598 }
72599 goto case 106;
72600 case 106:
72601 case 212:
72602 case 219:
72603 case 220:
72604 case 228:
72605 case 231:
72606 case 243:
72607 case 247:
72608 case 283:
72609 case 300:
72610 case 301:
72611 case 302:
72612 case 303:
72613 case 304:
72614 case 305:
72615 case 306:
72616 case 307:
72617 case 308:
72619 break;
72620 }
72621 break;
72622 }
72623 goto case 275;
72624 case 275:
72625 case 276:
72626 case 277:
72627 case 278:
72628 case 279:
72629 case 280:
72630 case 281:
72632 break;
72633 }
72634 break;
72635 }
72636 goto case 373;
72637 case 373:
72638 case 374:
72639 case 375:
72640 {
72642 if (
tile2 ==
null || !
tile2.active() ||
tile2.bottomSlope() || !Main.tileSolid[
tile2.type] || Main.tileSolidTop[
tile2.type])
72643 {
72645 }
72646 break;
72647 }
72648 }
72649 return;
72650 }
72652 {
72653 switch (num)
72654 {
72655 case 385:
72656 case 446:
72657 case 447:
72658 case 448:
72659 break;
72660 default:
72661 {
72671 int up = -1;
72673 int left = -1;
72674 int right = -1;
72676 int down = -1;
72679 {
72680 left = (Main.tileStone[
tile4.type] ? 1 :
tile4.type);
72681 if (
tile4.slope() == 1 ||
tile4.slope() == 3)
72682 {
72683 left = -1;
72684 }
72685 }
72687 {
72688 right = (Main.tileStone[
tile5.type] ? 1 :
tile5.type);
72689 if (
tile5.slope() == 2 ||
tile5.slope() == 4)
72690 {
72691 right = -1;
72692 }
72693 }
72695 {
72696 up = (Main.tileStone[
tile2.type] ? 1 :
tile2.type);
72697 if (
tile2.slope() == 3 ||
tile2.slope() == 4)
72698 {
72699 up = -1;
72700 }
72701 }
72703 {
72704 down = (Main.tileStone[
tile3.type] ? 1 :
tile3.type);
72705 if (
tile3.slope() == 1 ||
tile3.slope() == 2)
72706 {
72707 down = -1;
72708 }
72709 }
72711 {
72713 }
72715 {
72717 }
72719 {
72721 }
72723 {
72725 }
72726 if (tile.slope() == 2)
72727 {
72728 up = -1;
72729 left = -1;
72730 }
72731 if (tile.slope() == 1)
72732 {
72733 up = -1;
72734 right = -1;
72735 }
72736 if (tile.slope() == 4)
72737 {
72738 down = -1;
72739 left = -1;
72740 }
72741 if (tile.slope() == 3)
72742 {
72743 down = -1;
72744 right = -1;
72745 }
72746 if (num == 668)
72747 {
72748 num = 0;
72749 }
72751 switch (num)
72752 {
72753 case 147:
72754 TileMergeAttempt(num, Main.tileBrick,
TileID.
Sets.
Ices,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
72755 break;
72756 case 161:
72757 case 163:
72758 case 164:
72759 case 200:
72760 TileMergeAttempt(num, Main.tileBrick,
TileID.
Sets.
Snow,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
72761 break;
72762 case 162:
72763 TileMergeAttempt(num, Main.tileBrick,
TileID.
Sets.
IcesSnow,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
72764 break;
72765 default:
72766 if (Main.tileBrick[num])
72767 {
72768 switch (num)
72769 {
72770 case 60:
72771 case 70:
72772 case 661:
72773 case 662:
72774 TileMergeAttempt(num, Main.tileBrick,
TileID.
Sets.
Mud,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
72775 break;
72776 case 633:
72777 TileMergeAttempt(num, Main.tileBrick,
TileID.
Sets.
Ash,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
72778 break;
72779 default:
72781 break;
72782 }
72783 }
72784 else if (Main.tilePile[num])
72785 {
72787 }
72788 break;
72789 }
72790 if ((num == 1 || Main.tileMoss[num] || num == 117 || num == 25 || num == 203) && down == 165)
72791 {
72793 {
72794 down = num;
72795 }
72796 else if (
tile3 !=
null &&
tile3.frameY == 0)
72797 {
72798 down = num;
72799 }
72800 }
72801 if ((num == 1 || Main.tileMoss[num] || num == 117 || num == 25 || num == 203) && up == 165)
72802 {
72804 {
72805 up = num;
72806 }
72807 else if (
tile2 !=
null &&
tile2.frameY == 54)
72808 {
72809 up = num;
72810 }
72811 }
72812 if (num == 225)
72813 {
72814 if (down == 165)
72815 {
72816 down = num;
72817 }
72818 if (up == 165)
72819 {
72820 up = num;
72821 }
72822 }
72823 if ((num == 200 || num == 161 || num == 147 || num == 163 || num == 164) && down == 165)
72824 {
72825 down = num;
72826 }
72827 if ((tile.slope() == 1 || tile.slope() == 2) && down > -1 && !
TileID.
Sets.
Platforms[down])
72828 {
72829 down = num;
72830 }
72832 {
72833 up = num;
72834 }
72836 {
72837 up = num;
72838 }
72840 {
72841 down = num;
72842 }
72843 if (num == 124)
72844 {
72846 {
72847 up = num;
72848 }
72850 {
72851 down = num;
72852 }
72853 }
72855 {
72856 up = num;
72857 }
72858 if (left > -1 &&
tile4 !=
null &&
tile4.halfBrick())
72859 {
72860 if (tile.halfBrick())
72861 {
72862 left = num;
72863 }
72864 else if (
tile4.type != num)
72865 {
72866 left = -1;
72867 }
72868 }
72869 if (right > -1 &&
tile5 !=
null &&
tile5.halfBrick())
72870 {
72871 if (tile.halfBrick())
72872 {
72873 right = num;
72874 }
72875 else if (
tile5.type != num)
72876 {
72877 right = -1;
72878 }
72879 }
72880 if (tile.halfBrick())
72881 {
72882 if (left != num)
72883 {
72884 left = -1;
72885 }
72886 if (right != num)
72887 {
72888 right = -1;
72889 }
72890 up = -1;
72891 }
72893 {
72894 down = -1;
72895 }
72896 if (!Main.tileSolid[num])
72897 {
72898 switch (num)
72899 {
72900 case 49:
72902 return;
72903 case 80:
72905 return;
72906 }
72907 }
72914 {
72916 tile.frameNumber((
byte)
num27);
72917 }
72918 else
72919 {
72920 num27 = tile.frameNumber();
72921 }
72922 if (Main.tileLargeFrames[num] == 1)
72923 {
72926 num27 = (
new int[4, 3]
72927 {
72928 { 2, 4, 2 },
72929 { 1, 3, 1 },
72930 { 2, 2, 4 },
72931 { 1, 1, 3 }
72933 }
72934 if (Main.tileLargeFrames[num] == 2)
72935 {
72939 }
72941 {
72943 }
72944 if (Main.tileBlendAll[num])
72945 {
72947 }
72949 {
72951 }
72953 {
72954 if (up > -1 && Main.tileMergeDirt[up])
72955 {
72958 {
72959 up = num;
72960 }
72961 }
72962 else if (up == 147)
72963 {
72966 {
72967 up = num;
72968 }
72969 }
72970 if (down > -1 && Main.tileMergeDirt[down])
72971 {
72974 {
72975 down = num;
72976 }
72977 }
72978 else if (down == 147)
72979 {
72982 {
72983 down = num;
72984 }
72985 }
72986 if (left > -1 && Main.tileMergeDirt[left])
72987 {
72990 {
72991 left = num;
72992 }
72993 }
72994 else if (left == 147)
72995 {
72998 {
72999 left = num;
73000 }
73001 }
73002 if (right > -1 && Main.tileMergeDirt[right])
73003 {
73006 {
73007 right = num;
73008 }
73009 }
73010 else if (right == 147)
73011 {
73014 {
73015 right = num;
73016 }
73017 }
73020 {
73021 up = num;
73022 }
73024 {
73025 down = num;
73026 }
73028 {
73029 left = num;
73030 }
73032 {
73033 right = num;
73034 }
73036 {
73038 }
73040 {
73042 }
73044 {
73046 }
73048 {
73050 }
73052 {
73054 }
73056 {
73058 }
73060 {
73062 }
73064 {
73066 }
73071 {
73072 up = num;
73073 }
73075 {
73076 down = num;
73077 }
73079 {
73080 left = num;
73081 }
73083 {
73084 right = num;
73085 }
73087 {
73089 }
73091 {
73093 }
73095 {
73097 }
73099 {
73101 }
73102 }
73103 else if (Main.tileRope[num])
73104 {
73105 if (num != 504 && up != num &&
IsRope(i,
j - 1))
73106 {
73107 up = num;
73108 }
73109 if (down != num &&
IsRope(i,
j + 1))
73110 {
73111 down = num;
73112 }
73113 if (num != 504 && up > -1 && Main.tileSolid[up] && !Main.tileSolidTop[up])
73114 {
73115 up = num;
73116 }
73117 if (down > -1 && Main.tileSolid[down])
73118 {
73119 down = num;
73120 }
73121 if (num != 504 && up != num)
73122 {
73123 if (left > -1 && Main.tileSolid[left])
73124 {
73125 left = num;
73126 }
73127 if (right > -1 && Main.tileSolid[right])
73128 {
73129 right = num;
73130 }
73131 }
73132 }
73133 else
73134 {
73135 switch (num)
73136 {
73137 case 53:
73138 TileMergeAttemptFrametest(i,
j, num, 397,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73139 TileMergeAttemptFrametest(i,
j, num, 396,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73140 break;
73141 case 234:
73142 TileMergeAttemptFrametest(i,
j, num, 399,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73143 TileMergeAttemptFrametest(i,
j, num, 401,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73144 break;
73145 case 112:
73146 TileMergeAttemptFrametest(i,
j, num, 398,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73147 TileMergeAttemptFrametest(i,
j, num, 400,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73148 break;
73149 case 116:
73150 TileMergeAttemptFrametest(i,
j, num, 402,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73151 TileMergeAttemptFrametest(i,
j, num, 403,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73152 break;
73153 }
73154 }
73155 if (Main.tileMergeDirt[num])
73156 {
73158 if (num == 1)
73159 {
73160 if ((
double)
j > Main.rockLayer)
73161 {
73162 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
Mud,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73163 }
73164 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
Ash,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73165 }
73166 }
73167 else
73168 {
73169 switch (num)
73170 {
73171 case 58:
73172 case 75:
73173 case 76:
73175 break;
73176 case 57:
73179 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
HellSpecial,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73180 break;
73181 case 59:
73182 if ((
double)
j > Main.rockLayer)
73183 {
73185 }
73187 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
JungleSpecial,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73188 if ((
double)
j < Main.rockLayer)
73189 {
73190 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
Dirt,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73191 }
73192 else
73193 {
73195 }
73196 break;
73197 case 211:
73200 break;
73201 case 225:
73202 case 226:
73204 break;
73205 case 60:
73207 break;
73208 case 189:
73209 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
MergesWithClouds,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73210 break;
73211 case 196:
73214 break;
73215 case 460:
73218 break;
73219 case 147:
73220 TileMergeAttemptFrametest(i,
j, num,
TileID.
Sets.
IcesSlush,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73221 break;
73222 case 161:
73223 case 163:
73224 case 164:
73225 case 200:
73226 case 224:
73228 break;
73229 case 162:
73231 break;
73232 case 32:
73233 if (down == 23)
73234 {
73235 down = num;
73236 }
73237 break;
73238 case 352:
73239 if (down == 199)
73240 {
73241 down = num;
73242 }
73243 break;
73244 case 69:
73245 if (down == 60)
73246 {
73247 down = num;
73248 }
73249 break;
73250 case 655:
73251 if (down == 60)
73252 {
73253 down = num;
73254 }
73255 break;
73256 case 51:
73257 TileMergeAttempt(num,
TileID.
Sets.
AllTiles, Main.tileNoAttach,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73258 break;
73259 case 192:
73260 TileMergeAttemptFrametest(i,
j, num, 191,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73261 break;
73262 case 191:
73265 break;
73266 case 384:
73267 TileMergeAttemptFrametest(i,
j, num, 383,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73268 break;
73269 case 383:
73272 break;
73273 case 407:
73275 break;
73276 case 404:
73278 TileMergeAttemptFrametest(i,
j, num, 407,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73279 break;
73280 case 397:
73282 TileMergeAttemptFrametest(i,
j, num, 396,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73283 break;
73284 case 396:
73287 TileMergeAttemptFrametest(i,
j, num, 404,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73288 break;
73289 case 398:
73291 TileMergeAttemptFrametest(i,
j, num, 400,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73292 break;
73293 case 400:
73296 break;
73297 case 399:
73299 TileMergeAttemptFrametest(i,
j, num, 401,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73300 break;
73301 case 401:
73304 break;
73305 case 402:
73307 TileMergeAttemptFrametest(i,
j, num, 403,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73308 break;
73309 case 403:
73312 break;
73313 }
73314 }
73315 if (num == 0)
73316 {
73319 }
73321 {
73323 }
73324 else if (Main.tileStone[num] || num == 1)
73325 {
73327 }
73328 else if (num == 38)
73329 {
73331 }
73333 {
73335 }
73337 {
73339 }
73341 {
73343 }
73345 {
73347 }
73348 bool flag = false;
73350 if (!Main.ShouldShowInvisibleWalls())
73351 {
73352 bool flag2 = tile.invisibleBlock();
73353 tileMergeCullCache.CullTop |=
tile2 !=
null &&
tile2.invisibleBlock() !=
flag2;
73354 tileMergeCullCache.CullBottom |=
tile3 !=
null &&
tile3.invisibleBlock() !=
flag2;
73355 tileMergeCullCache.CullLeft |=
tile4 !=
null &&
tile4.invisibleBlock() !=
flag2;
73356 tileMergeCullCache.CullRight |=
tile5 !=
null &&
tile5.invisibleBlock() !=
flag2;
73357 tileMergeCullCache.CullTopLeft |=
tile8 !=
null &&
tile8.invisibleBlock() !=
flag2;
73358 tileMergeCullCache.CullTopRight |=
tile9 !=
null &&
tile9.invisibleBlock() !=
flag2;
73359 tileMergeCullCache.CullBottomLeft |=
tile6 !=
null &&
tile6.invisibleBlock() !=
flag2;
73360 tileMergeCullCache.CullBottomRight |=
tile7 !=
null &&
tile7.invisibleBlock() !=
flag2;
73361 }
73363 {
73364 flag = true;
73365 TileMergeAttemptWeird(num, -1, Main.tileSolid,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
73367 if (num == 60 || num == 70 || num == 661 || num == 662)
73368 {
73370 }
73371 else if (Main.tileMoss[num])
73372 {
73374 }
73376 {
73378 }
73379 else
73380 {
73381 switch (num)
73382 {
73383 case 2:
73384 case 477:
73386 break;
73387 case 23:
73389 break;
73390 }
73391 }
73393 if (up != num && up !=
num32 && (down == num || down ==
num32))
73394 {
73395 if (left ==
num32 && right == num)
73396 {
73398 {
73399 case 0:
73400 rectangle.X = 0;
73401 rectangle.Y = 198;
73402 break;
73403 case 1:
73404 rectangle.X = 18;
73405 rectangle.Y = 198;
73406 break;
73407 default:
73408 rectangle.X = 36;
73409 rectangle.Y = 198;
73410 break;
73411 }
73412 }
73413 else if (left == num && right ==
num32)
73414 {
73416 {
73417 case 0:
73418 rectangle.X = 54;
73419 rectangle.Y = 198;
73420 break;
73421 case 1:
73422 rectangle.X = 72;
73423 rectangle.Y = 198;
73424 break;
73425 default:
73426 rectangle.X = 90;
73427 rectangle.Y = 198;
73428 break;
73429 }
73430 }
73431 }
73432 else if (down != num && down !=
num32 && (up == num || up ==
num32))
73433 {
73434 if (left ==
num32 && right == num)
73435 {
73437 {
73438 case 0:
73439 rectangle.X = 0;
73440 rectangle.Y = 216;
73441 break;
73442 case 1:
73443 rectangle.X = 18;
73444 rectangle.Y = 216;
73445 break;
73446 default:
73447 rectangle.X = 36;
73448 rectangle.Y = 216;
73449 break;
73450 }
73451 }
73452 else if (left == num && right ==
num32)
73453 {
73455 {
73456 case 0:
73457 rectangle.X = 54;
73458 rectangle.Y = 216;
73459 break;
73460 case 1:
73461 rectangle.X = 72;
73462 rectangle.Y = 216;
73463 break;
73464 default:
73465 rectangle.X = 90;
73466 rectangle.Y = 216;
73467 break;
73468 }
73469 }
73470 }
73471 else if (left != num && left !=
num32 && (right == num || right ==
num32))
73472 {
73473 if (up ==
num32 && down == num)
73474 {
73476 {
73477 case 0:
73478 rectangle.X = 72;
73479 rectangle.Y = 144;
73480 break;
73481 case 1:
73482 rectangle.X = 72;
73483 rectangle.Y = 162;
73484 break;
73485 default:
73486 rectangle.X = 72;
73487 rectangle.Y = 180;
73488 break;
73489 }
73490 }
73491 else if (down == num && up ==
num32)
73492 {
73494 {
73495 case 0:
73496 rectangle.X = 72;
73497 rectangle.Y = 90;
73498 break;
73499 case 1:
73500 rectangle.X = 72;
73501 rectangle.Y = 108;
73502 break;
73503 default:
73504 rectangle.X = 72;
73505 rectangle.Y = 126;
73506 break;
73507 }
73508 }
73509 }
73510 else if (right != num && right !=
num32 && (left == num || left ==
num32))
73511 {
73512 if (up ==
num32 && down == num)
73513 {
73515 {
73516 case 0:
73517 rectangle.X = 90;
73518 rectangle.Y = 144;
73519 break;
73520 case 1:
73521 rectangle.X = 90;
73522 rectangle.Y = 162;
73523 break;
73524 default:
73525 rectangle.X = 90;
73526 rectangle.Y = 180;
73527 break;
73528 }
73529 }
73530 else if (down == num && right == up)
73531 {
73533 {
73534 case 0:
73535 rectangle.X = 90;
73536 rectangle.Y = 90;
73537 break;
73538 case 1:
73539 rectangle.X = 90;
73540 rectangle.Y = 108;
73541 break;
73542 default:
73543 rectangle.X = 90;
73544 rectangle.Y = 126;
73545 break;
73546 }
73547 }
73548 }
73549 else if (up == num && down == num && left == num && right == num)
73550 {
73552 {
73554 {
73556 {
73557 case 0:
73558 rectangle.X = 108;
73559 rectangle.Y = 324;
73560 break;
73561 case 1:
73562 rectangle.X = 126;
73563 rectangle.Y = 324;
73564 break;
73565 default:
73566 rectangle.X = 144;
73567 rectangle.Y = 324;
73568 break;
73569 }
73570 }
73572 {
73574 {
73575 case 0:
73576 rectangle.X = 108;
73577 rectangle.Y = 342;
73578 break;
73579 case 1:
73580 rectangle.X = 126;
73581 rectangle.Y = 342;
73582 break;
73583 default:
73584 rectangle.X = 144;
73585 rectangle.Y = 342;
73586 break;
73587 }
73588 }
73590 {
73592 {
73593 case 0:
73594 rectangle.X = 108;
73595 rectangle.Y = 360;
73596 break;
73597 case 1:
73598 rectangle.X = 126;
73599 rectangle.Y = 360;
73600 break;
73601 default:
73602 rectangle.X = 144;
73603 rectangle.Y = 360;
73604 break;
73605 }
73606 }
73608 {
73610 {
73611 case 0:
73612 rectangle.X = 108;
73613 rectangle.Y = 378;
73614 break;
73615 case 1:
73616 rectangle.X = 126;
73617 rectangle.Y = 378;
73618 break;
73619 default:
73620 rectangle.X = 144;
73621 rectangle.Y = 378;
73622 break;
73623 }
73624 }
73625 else
73626 {
73628 {
73629 case 0:
73630 rectangle.X = 144;
73631 rectangle.Y = 234;
73632 break;
73633 case 1:
73634 rectangle.X = 198;
73635 rectangle.Y = 234;
73636 break;
73637 default:
73638 rectangle.X = 252;
73639 rectangle.Y = 234;
73640 break;
73641 }
73642 }
73643 }
73645 {
73647 {
73648 case 0:
73649 rectangle.X = 36;
73650 rectangle.Y = 306;
73651 break;
73652 case 1:
73653 rectangle.X = 54;
73654 rectangle.Y = 306;
73655 break;
73656 default:
73657 rectangle.X = 72;
73658 rectangle.Y = 306;
73659 break;
73660 }
73661 }
73663 {
73665 {
73666 case 0:
73667 rectangle.X = 90;
73668 rectangle.Y = 306;
73669 break;
73670 case 1:
73671 rectangle.X = 108;
73672 rectangle.Y = 306;
73673 break;
73674 default:
73675 rectangle.X = 126;
73676 rectangle.Y = 306;
73677 break;
73678 }
73679 }
73681 {
73683 {
73684 case 0:
73685 rectangle.X = 54;
73686 rectangle.Y = 108;
73687 break;
73688 case 1:
73689 rectangle.X = 54;
73690 rectangle.Y = 144;
73691 break;
73692 default:
73693 rectangle.X = 54;
73694 rectangle.Y = 180;
73695 break;
73696 }
73697 }
73699 {
73701 {
73702 case 0:
73703 rectangle.X = 36;
73704 rectangle.Y = 108;
73705 break;
73706 case 1:
73707 rectangle.X = 36;
73708 rectangle.Y = 144;
73709 break;
73710 default:
73711 rectangle.X = 36;
73712 rectangle.Y = 180;
73713 break;
73714 }
73715 }
73717 {
73719 {
73720 case 0:
73721 rectangle.X = 54;
73722 rectangle.Y = 90;
73723 break;
73724 case 1:
73725 rectangle.X = 54;
73726 rectangle.Y = 126;
73727 break;
73728 default:
73729 rectangle.X = 54;
73730 rectangle.Y = 162;
73731 break;
73732 }
73733 }
73735 {
73737 {
73738 case 0:
73739 rectangle.X = 36;
73740 rectangle.Y = 90;
73741 break;
73742 case 1:
73743 rectangle.X = 36;
73744 rectangle.Y = 126;
73745 break;
73746 default:
73747 rectangle.X = 36;
73748 rectangle.Y = 162;
73749 break;
73750 }
73751 }
73752 }
73753 else if (up == num && down ==
num32 && left == num && right == num &&
upLeft == -1 &&
upRight == -1)
73754 {
73756 {
73757 case 0:
73758 rectangle.X = 108;
73759 rectangle.Y = 18;
73760 break;
73761 case 1:
73762 rectangle.X = 126;
73763 rectangle.Y = 18;
73764 break;
73765 default:
73766 rectangle.X = 144;
73767 rectangle.Y = 18;
73768 break;
73769 }
73770 }
73771 else if (up ==
num32 && down == num && left == num && right == num &&
downLeft == -1 &&
downRight == -1)
73772 {
73774 {
73775 case 0:
73776 rectangle.X = 108;
73777 rectangle.Y = 36;
73778 break;
73779 case 1:
73780 rectangle.X = 126;
73781 rectangle.Y = 36;
73782 break;
73783 default:
73784 rectangle.X = 144;
73785 rectangle.Y = 36;
73786 break;
73787 }
73788 }
73789 else if (up == num && down == num && left ==
num32 && right == num &&
upRight == -1 &&
downRight == -1)
73790 {
73792 {
73793 case 0:
73794 rectangle.X = 198;
73795 rectangle.Y = 0;
73796 break;
73797 case 1:
73798 rectangle.X = 198;
73799 rectangle.Y = 18;
73800 break;
73801 default:
73802 rectangle.X = 198;
73803 rectangle.Y = 36;
73804 break;
73805 }
73806 }
73807 else if (up == num && down == num && left == num && right ==
num32 &&
upLeft == -1 &&
downLeft == -1)
73808 {
73810 {
73811 case 0:
73812 rectangle.X = 180;
73813 rectangle.Y = 0;
73814 break;
73815 case 1:
73816 rectangle.X = 180;
73817 rectangle.Y = 18;
73818 break;
73819 default:
73820 rectangle.X = 180;
73821 rectangle.Y = 36;
73822 break;
73823 }
73824 }
73825 else if (up == num && down ==
num32 && left == num && right == num)
73826 {
73828 {
73830 {
73831 case 0:
73832 rectangle.X = 54;
73833 rectangle.Y = 108;
73834 break;
73835 case 1:
73836 rectangle.X = 54;
73837 rectangle.Y = 144;
73838 break;
73839 default:
73840 rectangle.X = 54;
73841 rectangle.Y = 180;
73842 break;
73843 }
73844 }
73846 {
73848 {
73849 case 0:
73850 rectangle.X = 36;
73851 rectangle.Y = 108;
73852 break;
73853 case 1:
73854 rectangle.X = 36;
73855 rectangle.Y = 144;
73856 break;
73857 default:
73858 rectangle.X = 36;
73859 rectangle.Y = 180;
73860 break;
73861 }
73862 }
73863 }
73864 else if (up ==
num32 && down == num && left == num && right == num)
73865 {
73867 {
73869 {
73870 case 0:
73871 rectangle.X = 54;
73872 rectangle.Y = 90;
73873 break;
73874 case 1:
73875 rectangle.X = 54;
73876 rectangle.Y = 126;
73877 break;
73878 default:
73879 rectangle.X = 54;
73880 rectangle.Y = 162;
73881 break;
73882 }
73883 }
73885 {
73887 {
73888 case 0:
73889 rectangle.X = 36;
73890 rectangle.Y = 90;
73891 break;
73892 case 1:
73893 rectangle.X = 36;
73894 rectangle.Y = 126;
73895 break;
73896 default:
73897 rectangle.X = 36;
73898 rectangle.Y = 162;
73899 break;
73900 }
73901 }
73902 }
73903 else if (up == num && down == num && left == num && right ==
num32)
73904 {
73906 {
73908 {
73909 case 0:
73910 rectangle.X = 54;
73911 rectangle.Y = 90;
73912 break;
73913 case 1:
73914 rectangle.X = 54;
73915 rectangle.Y = 126;
73916 break;
73917 default:
73918 rectangle.X = 54;
73919 rectangle.Y = 162;
73920 break;
73921 }
73922 }
73924 {
73926 {
73927 case 0:
73928 rectangle.X = 54;
73929 rectangle.Y = 108;
73930 break;
73931 case 1:
73932 rectangle.X = 54;
73933 rectangle.Y = 144;
73934 break;
73935 default:
73936 rectangle.X = 54;
73937 rectangle.Y = 180;
73938 break;
73939 }
73940 }
73941 }
73942 else if (up == num && down == num && left ==
num32 && right == num)
73943 {
73945 {
73947 {
73948 case 0:
73949 rectangle.X = 36;
73950 rectangle.Y = 90;
73951 break;
73952 case 1:
73953 rectangle.X = 36;
73954 rectangle.Y = 126;
73955 break;
73956 default:
73957 rectangle.X = 36;
73958 rectangle.Y = 162;
73959 break;
73960 }
73961 }
73963 {
73965 {
73966 case 0:
73967 rectangle.X = 36;
73968 rectangle.Y = 108;
73969 break;
73970 case 1:
73971 rectangle.X = 36;
73972 rectangle.Y = 144;
73973 break;
73974 default:
73975 rectangle.X = 36;
73976 rectangle.Y = 180;
73977 break;
73978 }
73979 }
73980 }
73981 else if ((up ==
num32 && down == num && left == num && right == num) || (up == num && down ==
num32 && left == num && right == num) || (up == num && down == num && left ==
num32 && right == num) || (up == num && down == num && left == num && right ==
num32))
73982 {
73984 {
73985 case 0:
73986 rectangle.X = 18;
73987 rectangle.Y = 18;
73988 break;
73989 case 1:
73990 rectangle.X = 36;
73991 rectangle.Y = 18;
73992 break;
73993 default:
73994 rectangle.X = 54;
73995 rectangle.Y = 18;
73996 break;
73997 }
73998 }
73999 if ((up == num || up ==
num32) && (down == num || down ==
num32) && (left == num || left ==
num32) && (right == num || right ==
num32))
74000 {
74002 {
74004 {
74005 case 0:
74006 rectangle.X = 54;
74007 rectangle.Y = 108;
74008 break;
74009 case 1:
74010 rectangle.X = 54;
74011 rectangle.Y = 144;
74012 break;
74013 default:
74014 rectangle.X = 54;
74015 rectangle.Y = 180;
74016 break;
74017 }
74018 }
74020 {
74022 {
74023 case 0:
74024 rectangle.X = 36;
74025 rectangle.Y = 108;
74026 break;
74027 case 1:
74028 rectangle.X = 36;
74029 rectangle.Y = 144;
74030 break;
74031 default:
74032 rectangle.X = 36;
74033 rectangle.Y = 180;
74034 break;
74035 }
74036 }
74038 {
74040 {
74041 case 0:
74042 rectangle.X = 54;
74043 rectangle.Y = 90;
74044 break;
74045 case 1:
74046 rectangle.X = 54;
74047 rectangle.Y = 126;
74048 break;
74049 default:
74050 rectangle.X = 54;
74051 rectangle.Y = 162;
74052 break;
74053 }
74054 }
74056 {
74058 {
74059 case 0:
74060 rectangle.X = 36;
74061 rectangle.Y = 90;
74062 break;
74063 case 1:
74064 rectangle.X = 36;
74065 rectangle.Y = 126;
74066 break;
74067 default:
74068 rectangle.X = 36;
74069 rectangle.Y = 162;
74070 break;
74071 }
74072 }
74073 }
74075 {
74077 {
74078 case 0:
74079 rectangle.X = 90;
74080 rectangle.Y = 270;
74081 break;
74082 case 1:
74083 rectangle.X = 108;
74084 rectangle.Y = 270;
74085 break;
74086 default:
74087 rectangle.X = 126;
74088 rectangle.Y = 270;
74089 break;
74090 }
74091 }
74093 {
74095 {
74096 case 0:
74097 rectangle.X = 144;
74098 rectangle.Y = 270;
74099 break;
74100 case 1:
74101 rectangle.X = 162;
74102 rectangle.Y = 270;
74103 break;
74104 default:
74105 rectangle.X = 180;
74106 rectangle.Y = 270;
74107 break;
74108 }
74109 }
74111 {
74113 {
74114 case 0:
74115 rectangle.X = 90;
74116 rectangle.Y = 288;
74117 break;
74118 case 1:
74119 rectangle.X = 108;
74120 rectangle.Y = 288;
74121 break;
74122 default:
74123 rectangle.X = 126;
74124 rectangle.Y = 288;
74125 break;
74126 }
74127 }
74128 else if (down !=
num32 && down != num && up == num && left == num && right !=
num32 && right != num &&
upLeft !=
num32 &&
upLeft != num)
74129 {
74131 {
74132 case 0:
74133 rectangle.X = 144;
74134 rectangle.Y = 288;
74135 break;
74136 case 1:
74137 rectangle.X = 162;
74138 rectangle.Y = 288;
74139 break;
74140 default:
74141 rectangle.X = 180;
74142 rectangle.Y = 288;
74143 break;
74144 }
74145 }
74147 {
74149 {
74150 case 0:
74151 rectangle.X = 144;
74152 rectangle.Y = 216;
74153 break;
74154 case 1:
74155 rectangle.X = 198;
74156 rectangle.Y = 216;
74157 break;
74158 default:
74159 rectangle.X = 252;
74160 rectangle.Y = 216;
74161 break;
74162 }
74163 }
74165 {
74167 {
74168 case 0:
74169 rectangle.X = 144;
74170 rectangle.Y = 252;
74171 break;
74172 case 1:
74173 rectangle.X = 198;
74174 rectangle.Y = 252;
74175 break;
74176 default:
74177 rectangle.X = 252;
74178 rectangle.Y = 252;
74179 break;
74180 }
74181 }
74183 {
74185 {
74186 case 0:
74187 rectangle.X = 126;
74188 rectangle.Y = 234;
74189 break;
74190 case 1:
74191 rectangle.X = 180;
74192 rectangle.Y = 234;
74193 break;
74194 default:
74195 rectangle.X = 234;
74196 rectangle.Y = 234;
74197 break;
74198 }
74199 }
74201 {
74203 {
74204 case 0:
74205 rectangle.X = 162;
74206 rectangle.Y = 234;
74207 break;
74208 case 1:
74209 rectangle.X = 216;
74210 rectangle.Y = 234;
74211 break;
74212 default:
74213 rectangle.X = 270;
74214 rectangle.Y = 234;
74215 break;
74216 }
74217 }
74218 else if (up !=
num32 && up != num && (down ==
num32 || down == num) && left ==
num32 && right ==
num32)
74219 {
74221 {
74222 case 0:
74223 rectangle.X = 36;
74224 rectangle.Y = 270;
74225 break;
74226 case 1:
74227 rectangle.X = 54;
74228 rectangle.Y = 270;
74229 break;
74230 default:
74231 rectangle.X = 72;
74232 rectangle.Y = 270;
74233 break;
74234 }
74235 }
74236 else if (down !=
num32 && down != num && (up ==
num32 || up == num) && left ==
num32 && right ==
num32)
74237 {
74239 {
74240 case 0:
74241 rectangle.X = 36;
74242 rectangle.Y = 288;
74243 break;
74244 case 1:
74245 rectangle.X = 54;
74246 rectangle.Y = 288;
74247 break;
74248 default:
74249 rectangle.X = 72;
74250 rectangle.Y = 288;
74251 break;
74252 }
74253 }
74254 else if (left !=
num32 && left != num && (right ==
num32 || right == num) && up ==
num32 && down ==
num32)
74255 {
74257 {
74258 case 0:
74259 rectangle.X = 0;
74260 rectangle.Y = 270;
74261 break;
74262 case 1:
74263 rectangle.X = 0;
74264 rectangle.Y = 288;
74265 break;
74266 default:
74267 rectangle.X = 0;
74268 rectangle.Y = 306;
74269 break;
74270 }
74271 }
74272 else if (right !=
num32 && right != num && (left ==
num32 || left == num) && up ==
num32 && down ==
num32)
74273 {
74275 {
74276 case 0:
74277 rectangle.X = 18;
74278 rectangle.Y = 270;
74279 break;
74280 case 1:
74281 rectangle.X = 18;
74282 rectangle.Y = 288;
74283 break;
74284 default:
74285 rectangle.X = 18;
74286 rectangle.Y = 306;
74287 break;
74288 }
74289 }
74290 else if (up == num && down ==
num32 && left ==
num32 && right ==
num32)
74291 {
74293 {
74294 case 0:
74295 rectangle.X = 198;
74296 rectangle.Y = 288;
74297 break;
74298 case 1:
74299 rectangle.X = 216;
74300 rectangle.Y = 288;
74301 break;
74302 default:
74303 rectangle.X = 234;
74304 rectangle.Y = 288;
74305 break;
74306 }
74307 }
74308 else if (up ==
num32 && down == num && left ==
num32 && right ==
num32)
74309 {
74311 {
74312 case 0:
74313 rectangle.X = 198;
74314 rectangle.Y = 270;
74315 break;
74316 case 1:
74317 rectangle.X = 216;
74318 rectangle.Y = 270;
74319 break;
74320 default:
74321 rectangle.X = 234;
74322 rectangle.Y = 270;
74323 break;
74324 }
74325 }
74326 else if (up ==
num32 && down ==
num32 && left == num && right ==
num32)
74327 {
74329 {
74330 case 0:
74331 rectangle.X = 198;
74332 rectangle.Y = 306;
74333 break;
74334 case 1:
74335 rectangle.X = 216;
74336 rectangle.Y = 306;
74337 break;
74338 default:
74339 rectangle.X = 234;
74340 rectangle.Y = 306;
74341 break;
74342 }
74343 }
74344 else if (up ==
num32 && down ==
num32 && left ==
num32 && right == num)
74345 {
74347 {
74348 case 0:
74349 rectangle.X = 144;
74350 rectangle.Y = 306;
74351 break;
74352 case 1:
74353 rectangle.X = 162;
74354 rectangle.Y = 306;
74355 break;
74356 default:
74357 rectangle.X = 180;
74358 rectangle.Y = 306;
74359 break;
74360 }
74361 }
74362 if (up != num && up !=
num32 && down == num && left == num && right == num)
74363 {
74365 {
74367 {
74368 case 0:
74369 rectangle.X = 0;
74370 rectangle.Y = 324;
74371 break;
74372 case 1:
74373 rectangle.X = 18;
74374 rectangle.Y = 324;
74375 break;
74376 default:
74377 rectangle.X = 36;
74378 rectangle.Y = 324;
74379 break;
74380 }
74381 }
74383 {
74385 {
74386 case 0:
74387 rectangle.X = 54;
74388 rectangle.Y = 324;
74389 break;
74390 case 1:
74391 rectangle.X = 72;
74392 rectangle.Y = 324;
74393 break;
74394 default:
74395 rectangle.X = 90;
74396 rectangle.Y = 324;
74397 break;
74398 }
74399 }
74400 }
74401 else if (down != num && down !=
num32 && up == num && left == num && right == num)
74402 {
74404 {
74406 {
74407 case 0:
74408 rectangle.X = 0;
74409 rectangle.Y = 342;
74410 break;
74411 case 1:
74412 rectangle.X = 18;
74413 rectangle.Y = 342;
74414 break;
74415 default:
74416 rectangle.X = 36;
74417 rectangle.Y = 342;
74418 break;
74419 }
74420 }
74422 {
74424 {
74425 case 0:
74426 rectangle.X = 54;
74427 rectangle.Y = 342;
74428 break;
74429 case 1:
74430 rectangle.X = 72;
74431 rectangle.Y = 342;
74432 break;
74433 default:
74434 rectangle.X = 90;
74435 rectangle.Y = 342;
74436 break;
74437 }
74438 }
74439 }
74440 else if (left != num && left !=
num32 && up == num && down == num && right == num)
74441 {
74443 {
74445 {
74446 case 0:
74447 rectangle.X = 54;
74448 rectangle.Y = 360;
74449 break;
74450 case 1:
74451 rectangle.X = 72;
74452 rectangle.Y = 360;
74453 break;
74454 default:
74455 rectangle.X = 90;
74456 rectangle.Y = 360;
74457 break;
74458 }
74459 }
74461 {
74463 {
74464 case 0:
74465 rectangle.X = 0;
74466 rectangle.Y = 360;
74467 break;
74468 case 1:
74469 rectangle.X = 18;
74470 rectangle.Y = 360;
74471 break;
74472 default:
74473 rectangle.X = 36;
74474 rectangle.Y = 360;
74475 break;
74476 }
74477 }
74478 }
74479 else if (right != num && right !=
num32 && up == num && down == num && left == num)
74480 {
74482 {
74484 {
74485 case 0:
74486 rectangle.X = 0;
74487 rectangle.Y = 378;
74488 break;
74489 case 1:
74490 rectangle.X = 18;
74491 rectangle.Y = 378;
74492 break;
74493 default:
74494 rectangle.X = 36;
74495 rectangle.Y = 378;
74496 break;
74497 }
74498 }
74500 {
74502 {
74503 case 0:
74504 rectangle.X = 54;
74505 rectangle.Y = 378;
74506 break;
74507 case 1:
74508 rectangle.X = 72;
74509 rectangle.Y = 378;
74510 break;
74511 default:
74512 rectangle.X = 90;
74513 rectangle.Y = 378;
74514 break;
74515 }
74516 }
74517 }
74519 {
74520 if ((i +
j) % 2 == 1)
74521 {
74523 {
74524 case 0:
74525 rectangle.X = 108;
74526 rectangle.Y = 198;
74527 break;
74528 case 1:
74529 rectangle.X = 126;
74530 rectangle.Y = 198;
74531 break;
74532 default:
74533 rectangle.X = 144;
74534 rectangle.Y = 198;
74535 break;
74536 }
74537 }
74538 else
74539 {
74541 {
74542 case 0:
74543 rectangle.X = 18;
74544 rectangle.Y = 18;
74545 break;
74546 case 1:
74547 rectangle.X = 36;
74548 rectangle.Y = 18;
74549 break;
74550 default:
74551 rectangle.X = 54;
74552 rectangle.Y = 18;
74553 break;
74554 }
74555 }
74556 }
74558 {
74560 }
74562 {
74564 }
74565 else
74566 {
74568 }
74570 }
74573 {
74574 if (!flag)
74575 {
74576 flag = true;
74577 TileMergeAttemptWeird(num, -1, Main.tileSolid,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
74578 }
74579 if (up > -1 && up != num)
74580 {
74581 up = -1;
74582 }
74583 if (down > -1 && down != num)
74584 {
74585 down = -1;
74586 }
74587 if (left > -1 && left != num)
74588 {
74589 left = -1;
74590 }
74591 if (right > -1 && right != num)
74592 {
74593 right = -1;
74594 }
74596 if (up != -1 && down != -1 && left != -1 && right != -1)
74597 {
74598 if (up == -2 && down == num && left == num && right == num)
74599 {
74601 {
74602 case 0:
74603 rectangle.X = 144;
74604 rectangle.Y = 108;
74605 break;
74606 case 1:
74607 rectangle.X = 162;
74608 rectangle.Y = 108;
74609 break;
74610 default:
74611 rectangle.X = 180;
74612 rectangle.Y = 108;
74613 break;
74614 }
74616 }
74617 else if (up == num && down == -2 && left == num && right == num)
74618 {
74620 {
74621 case 0:
74622 rectangle.X = 144;
74623 rectangle.Y = 90;
74624 break;
74625 case 1:
74626 rectangle.X = 162;
74627 rectangle.Y = 90;
74628 break;
74629 default:
74630 rectangle.X = 180;
74631 rectangle.Y = 90;
74632 break;
74633 }
74635 }
74636 else if (up == num && down == num && left == -2 && right == num)
74637 {
74639 {
74640 case 0:
74641 rectangle.X = 162;
74642 rectangle.Y = 126;
74643 break;
74644 case 1:
74645 rectangle.X = 162;
74646 rectangle.Y = 144;
74647 break;
74648 default:
74649 rectangle.X = 162;
74650 rectangle.Y = 162;
74651 break;
74652 }
74654 }
74655 else if (up == num && down == num && left == num && right == -2)
74656 {
74658 {
74659 case 0:
74660 rectangle.X = 144;
74661 rectangle.Y = 126;
74662 break;
74663 case 1:
74664 rectangle.X = 144;
74665 rectangle.Y = 144;
74666 break;
74667 default:
74668 rectangle.X = 144;
74669 rectangle.Y = 162;
74670 break;
74671 }
74673 }
74674 else if (up == -2 && down == num && left == -2 && right == num)
74675 {
74677 {
74678 case 0:
74679 rectangle.X = 36;
74680 rectangle.Y = 90;
74681 break;
74682 case 1:
74683 rectangle.X = 36;
74684 rectangle.Y = 126;
74685 break;
74686 default:
74687 rectangle.X = 36;
74688 rectangle.Y = 162;
74689 break;
74690 }
74693 }
74694 else if (up == -2 && down == num && left == num && right == -2)
74695 {
74697 {
74698 case 0:
74699 rectangle.X = 54;
74700 rectangle.Y = 90;
74701 break;
74702 case 1:
74703 rectangle.X = 54;
74704 rectangle.Y = 126;
74705 break;
74706 default:
74707 rectangle.X = 54;
74708 rectangle.Y = 162;
74709 break;
74710 }
74713 }
74714 else if (up == num && down == -2 && left == -2 && right == num)
74715 {
74717 {
74718 case 0:
74719 rectangle.X = 36;
74720 rectangle.Y = 108;
74721 break;
74722 case 1:
74723 rectangle.X = 36;
74724 rectangle.Y = 144;
74725 break;
74726 default:
74727 rectangle.X = 36;
74728 rectangle.Y = 180;
74729 break;
74730 }
74733 }
74734 else if (up == num && down == -2 && left == num && right == -2)
74735 {
74737 {
74738 case 0:
74739 rectangle.X = 54;
74740 rectangle.Y = 108;
74741 break;
74742 case 1:
74743 rectangle.X = 54;
74744 rectangle.Y = 144;
74745 break;
74746 default:
74747 rectangle.X = 54;
74748 rectangle.Y = 180;
74749 break;
74750 }
74753 }
74754 else if (up == num && down == num && left == -2 && right == -2)
74755 {
74757 {
74758 case 0:
74759 rectangle.X = 180;
74760 rectangle.Y = 126;
74761 break;
74762 case 1:
74763 rectangle.X = 180;
74764 rectangle.Y = 144;
74765 break;
74766 default:
74767 rectangle.X = 180;
74768 rectangle.Y = 162;
74769 break;
74770 }
74773 }
74774 else if (up == -2 && down == -2 && left == num && right == num)
74775 {
74777 {
74778 case 0:
74779 rectangle.X = 144;
74780 rectangle.Y = 180;
74781 break;
74782 case 1:
74783 rectangle.X = 162;
74784 rectangle.Y = 180;
74785 break;
74786 default:
74787 rectangle.X = 180;
74788 rectangle.Y = 180;
74789 break;
74790 }
74793 }
74794 else if (up == -2 && down == num && left == -2 && right == -2)
74795 {
74797 {
74798 case 0:
74799 rectangle.X = 198;
74800 rectangle.Y = 90;
74801 break;
74802 case 1:
74803 rectangle.X = 198;
74804 rectangle.Y = 108;
74805 break;
74806 default:
74807 rectangle.X = 198;
74808 rectangle.Y = 126;
74809 break;
74810 }
74814 }
74815 else if (up == num && down == -2 && left == -2 && right == -2)
74816 {
74818 {
74819 case 0:
74820 rectangle.X = 198;
74821 rectangle.Y = 144;
74822 break;
74823 case 1:
74824 rectangle.X = 198;
74825 rectangle.Y = 162;
74826 break;
74827 default:
74828 rectangle.X = 198;
74829 rectangle.Y = 180;
74830 break;
74831 }
74835 }
74836 else if (up == -2 && down == -2 && left == num && right == -2)
74837 {
74839 {
74840 case 0:
74841 rectangle.X = 216;
74842 rectangle.Y = 144;
74843 break;
74844 case 1:
74845 rectangle.X = 216;
74846 rectangle.Y = 162;
74847 break;
74848 default:
74849 rectangle.X = 216;
74850 rectangle.Y = 180;
74851 break;
74852 }
74856 }
74857 else if (up == -2 && down == -2 && left == -2 && right == num)
74858 {
74860 {
74861 case 0:
74862 rectangle.X = 216;
74863 rectangle.Y = 90;
74864 break;
74865 case 1:
74866 rectangle.X = 216;
74867 rectangle.Y = 108;
74868 break;
74869 default:
74870 rectangle.X = 216;
74871 rectangle.Y = 126;
74872 break;
74873 }
74877 }
74878 else if (up == -2 && down == -2 && left == -2 && right == -2)
74879 {
74881 {
74882 case 0:
74883 rectangle.X = 108;
74884 rectangle.Y = 198;
74885 break;
74886 case 1:
74887 rectangle.X = 126;
74888 rectangle.Y = 198;
74889 break;
74890 default:
74891 rectangle.X = 144;
74892 rectangle.Y = 198;
74893 break;
74894 }
74899 }
74900 else if (up == num && down == num && left == num && right == num)
74901 {
74903 {
74905 {
74906 case 0:
74907 rectangle.X = 18;
74908 rectangle.Y = 108;
74909 break;
74910 case 1:
74911 rectangle.X = 18;
74912 rectangle.Y = 144;
74913 break;
74914 default:
74915 rectangle.X = 18;
74916 rectangle.Y = 180;
74917 break;
74918 }
74919 }
74921 {
74923 {
74924 case 0:
74925 rectangle.X = 0;
74926 rectangle.Y = 108;
74927 break;
74928 case 1:
74929 rectangle.X = 0;
74930 rectangle.Y = 144;
74931 break;
74932 default:
74933 rectangle.X = 0;
74934 rectangle.Y = 180;
74935 break;
74936 }
74937 }
74939 {
74941 {
74942 case 0:
74943 rectangle.X = 18;
74944 rectangle.Y = 90;
74945 break;
74946 case 1:
74947 rectangle.X = 18;
74948 rectangle.Y = 126;
74949 break;
74950 default:
74951 rectangle.X = 18;
74952 rectangle.Y = 162;
74953 break;
74954 }
74955 }
74957 {
74959 {
74960 case 0:
74961 rectangle.X = 0;
74962 rectangle.Y = 90;
74963 break;
74964 case 1:
74965 rectangle.X = 0;
74966 rectangle.Y = 126;
74967 break;
74968 default:
74969 rectangle.X = 0;
74970 rectangle.Y = 162;
74971 break;
74972 }
74973 }
74974 }
74975 }
74976 else
74977 {
74978 if (num != 2 && num != 23 && num != 60 && num != 70 && num != 109 && num != 199 && num != 477 && num != 492 && num != 633 && num != 661 && num != 662)
74979 {
74980 if (up == -1 && down == -2 && left == num && right == num)
74981 {
74983 {
74984 case 0:
74985 rectangle.X = 234;
74986 rectangle.Y = 0;
74987 break;
74988 case 1:
74989 rectangle.X = 252;
74990 rectangle.Y = 0;
74991 break;
74992 default:
74993 rectangle.X = 270;
74994 rectangle.Y = 0;
74995 break;
74996 }
74998 }
74999 else if (up == -2 && down == -1 && left == num && right == num)
75000 {
75002 {
75003 case 0:
75004 rectangle.X = 234;
75005 rectangle.Y = 18;
75006 break;
75007 case 1:
75008 rectangle.X = 252;
75009 rectangle.Y = 18;
75010 break;
75011 default:
75012 rectangle.X = 270;
75013 rectangle.Y = 18;
75014 break;
75015 }
75017 }
75018 else if (up == num && down == num && left == -1 && right == -2)
75019 {
75021 {
75022 case 0:
75023 rectangle.X = 234;
75024 rectangle.Y = 36;
75025 break;
75026 case 1:
75027 rectangle.X = 252;
75028 rectangle.Y = 36;
75029 break;
75030 default:
75031 rectangle.X = 270;
75032 rectangle.Y = 36;
75033 break;
75034 }
75036 }
75037 else if (up == num && down == num && left == -2 && right == -1)
75038 {
75040 {
75041 case 0:
75042 rectangle.X = 234;
75043 rectangle.Y = 54;
75044 break;
75045 case 1:
75046 rectangle.X = 252;
75047 rectangle.Y = 54;
75048 break;
75049 default:
75050 rectangle.X = 270;
75051 rectangle.Y = 54;
75052 break;
75053 }
75055 }
75056 }
75057 if (up != -1 && down != -1 && left == -1 && right == num)
75058 {
75059 if (up == -2 && down == num)
75060 {
75062 {
75063 case 0:
75064 rectangle.X = 72;
75065 rectangle.Y = 144;
75066 break;
75067 case 1:
75068 rectangle.X = 72;
75069 rectangle.Y = 162;
75070 break;
75071 default:
75072 rectangle.X = 72;
75073 rectangle.Y = 180;
75074 break;
75075 }
75077 }
75078 else if (down == -2 && up == num)
75079 {
75081 {
75082 case 0:
75083 rectangle.X = 72;
75084 rectangle.Y = 90;
75085 break;
75086 case 1:
75087 rectangle.X = 72;
75088 rectangle.Y = 108;
75089 break;
75090 default:
75091 rectangle.X = 72;
75092 rectangle.Y = 126;
75093 break;
75094 }
75096 }
75097 }
75098 else if (up != -1 && down != -1 && left == num && right == -1)
75099 {
75100 if (up == -2 && down == num)
75101 {
75103 {
75104 case 0:
75105 rectangle.X = 90;
75106 rectangle.Y = 144;
75107 break;
75108 case 1:
75109 rectangle.X = 90;
75110 rectangle.Y = 162;
75111 break;
75112 default:
75113 rectangle.X = 90;
75114 rectangle.Y = 180;
75115 break;
75116 }
75118 }
75119 else if (down == -2 && up == num)
75120 {
75122 {
75123 case 0:
75124 rectangle.X = 90;
75125 rectangle.Y = 90;
75126 break;
75127 case 1:
75128 rectangle.X = 90;
75129 rectangle.Y = 108;
75130 break;
75131 default:
75132 rectangle.X = 90;
75133 rectangle.Y = 126;
75134 break;
75135 }
75137 }
75138 }
75139 else if (up == -1 && down == num && left != -1 && right != -1)
75140 {
75141 if (left == -2 && right == num)
75142 {
75144 {
75145 case 0:
75146 rectangle.X = 0;
75147 rectangle.Y = 198;
75148 break;
75149 case 1:
75150 rectangle.X = 18;
75151 rectangle.Y = 198;
75152 break;
75153 default:
75154 rectangle.X = 36;
75155 rectangle.Y = 198;
75156 break;
75157 }
75159 }
75160 else if (right == -2 && left == num)
75161 {
75163 {
75164 case 0:
75165 rectangle.X = 54;
75166 rectangle.Y = 198;
75167 break;
75168 case 1:
75169 rectangle.X = 72;
75170 rectangle.Y = 198;
75171 break;
75172 default:
75173 rectangle.X = 90;
75174 rectangle.Y = 198;
75175 break;
75176 }
75178 }
75179 }
75180 else if (up == num && down == -1 && left != -1 && right != -1)
75181 {
75182 if (left == -2 && right == num)
75183 {
75185 {
75186 case 0:
75187 rectangle.X = 0;
75188 rectangle.Y = 216;
75189 break;
75190 case 1:
75191 rectangle.X = 18;
75192 rectangle.Y = 216;
75193 break;
75194 default:
75195 rectangle.X = 36;
75196 rectangle.Y = 216;
75197 break;
75198 }
75200 }
75201 else if (right == -2 && left == num)
75202 {
75204 {
75205 case 0:
75206 rectangle.X = 54;
75207 rectangle.Y = 216;
75208 break;
75209 case 1:
75210 rectangle.X = 72;
75211 rectangle.Y = 216;
75212 break;
75213 default:
75214 rectangle.X = 90;
75215 rectangle.Y = 216;
75216 break;
75217 }
75219 }
75220 }
75221 else if (up != -1 && down != -1 && left == -1 && right == -1)
75222 {
75223 if (up == -2 && down == -2)
75224 {
75226 {
75227 case 0:
75228 rectangle.X = 108;
75229 rectangle.Y = 216;
75230 break;
75231 case 1:
75232 rectangle.X = 108;
75233 rectangle.Y = 234;
75234 break;
75235 default:
75236 rectangle.X = 108;
75237 rectangle.Y = 252;
75238 break;
75239 }
75242 }
75243 else if (up == -2)
75244 {
75246 {
75247 case 0:
75248 rectangle.X = 126;
75249 rectangle.Y = 144;
75250 break;
75251 case 1:
75252 rectangle.X = 126;
75253 rectangle.Y = 162;
75254 break;
75255 default:
75256 rectangle.X = 126;
75257 rectangle.Y = 180;
75258 break;
75259 }
75261 }
75262 else if (down == -2)
75263 {
75265 {
75266 case 0:
75267 rectangle.X = 126;
75268 rectangle.Y = 90;
75269 break;
75270 case 1:
75271 rectangle.X = 126;
75272 rectangle.Y = 108;
75273 break;
75274 default:
75275 rectangle.X = 126;
75276 rectangle.Y = 126;
75277 break;
75278 }
75280 }
75281 }
75282 else if (up == -1 && down == -1 && left != -1 && right != -1)
75283 {
75284 if (left == -2 && right == -2)
75285 {
75287 {
75288 case 0:
75289 rectangle.X = 162;
75290 rectangle.Y = 198;
75291 break;
75292 case 1:
75293 rectangle.X = 180;
75294 rectangle.Y = 198;
75295 break;
75296 default:
75297 rectangle.X = 198;
75298 rectangle.Y = 198;
75299 break;
75300 }
75303 }
75304 else if (left == -2)
75305 {
75307 {
75308 case 0:
75309 rectangle.X = 0;
75310 rectangle.Y = 252;
75311 break;
75312 case 1:
75313 rectangle.X = 18;
75314 rectangle.Y = 252;
75315 break;
75316 default:
75317 rectangle.X = 36;
75318 rectangle.Y = 252;
75319 break;
75320 }
75322 }
75323 else if (right == -2)
75324 {
75326 {
75327 case 0:
75328 rectangle.X = 54;
75329 rectangle.Y = 252;
75330 break;
75331 case 1:
75332 rectangle.X = 72;
75333 rectangle.Y = 252;
75334 break;
75335 default:
75336 rectangle.X = 90;
75337 rectangle.Y = 252;
75338 break;
75339 }
75341 }
75342 }
75343 else if (up == -2 && down == -1 && left == -1 && right == -1)
75344 {
75346 {
75347 case 0:
75348 rectangle.X = 108;
75349 rectangle.Y = 144;
75350 break;
75351 case 1:
75352 rectangle.X = 108;
75353 rectangle.Y = 162;
75354 break;
75355 default:
75356 rectangle.X = 108;
75357 rectangle.Y = 180;
75358 break;
75359 }
75361 }
75362 else if (up == -1 && down == -2 && left == -1 && right == -1)
75363 {
75365 {
75366 case 0:
75367 rectangle.X = 108;
75368 rectangle.Y = 90;
75369 break;
75370 case 1:
75371 rectangle.X = 108;
75372 rectangle.Y = 108;
75373 break;
75374 default:
75375 rectangle.X = 108;
75376 rectangle.Y = 126;
75377 break;
75378 }
75380 }
75381 else if (up == -1 && down == -1 && left == -2 && right == -1)
75382 {
75384 {
75385 case 0:
75386 rectangle.X = 0;
75387 rectangle.Y = 234;
75388 break;
75389 case 1:
75390 rectangle.X = 18;
75391 rectangle.Y = 234;
75392 break;
75393 default:
75394 rectangle.X = 36;
75395 rectangle.Y = 234;
75396 break;
75397 }
75399 }
75400 else if (up == -1 && down == -1 && left == -1 && right == -2)
75401 {
75403 {
75404 case 0:
75405 rectangle.X = 54;
75406 rectangle.Y = 234;
75407 break;
75408 case 1:
75409 rectangle.X = 72;
75410 rectangle.Y = 234;
75411 break;
75412 default:
75413 rectangle.X = 90;
75414 rectangle.Y = 234;
75415 break;
75416 }
75418 }
75419 }
75420 }
75421 int num33 = tile.blockType();
75423 {
75425 {
75433 {
75437 {
75440 }
75442 {
75446 {
75448 }
75450 {
75452 }
75453 else
75454 {
75457 }
75458 }
75459 else
75460 {
75464 {
75467 }
75469 {
75471 }
75472 else
75473 {
75476 }
75477 }
75478 rectangle.X = (18 +
num34) * 18;
75479 rectangle.Y =
num35 * 18;
75480 }
75481 else
75482 {
75483 if (
flag3 &&
flag4 && num == down && num == right)
75484 {
75486 }
75487 else if (
flag3 &&
flag5 && num == down && num == left)
75488 {
75491 }
75492 else if (
flag5 &&
flag6 && num == up && num == left)
75493 {
75496 }
75497 else if (
flag6 &&
flag4 && num == up && num == right)
75498 {
75500 }
75502 {
75503 rectangle.X = (18 +
num34) * 18;
75504 rectangle.Y =
num35 * 18;
75505 }
75506 }
75507 }
75509 {
75516 {
75517 case 2:
75522 break;
75523 case 3:
75527 break;
75528 case 4:
75534 break;
75535 case 5:
75540 break;
75541 }
75543 {
75545 {
75547 }
75548 else if (num ==
num40)
75549 {
75551 }
75552 else if (num ==
num41)
75553 {
75556 }
75557 else
75558 {
75561 }
75562 }
75563 rectangle.X = (18 +
num43) * 18;
75564 rectangle.Y =
num44 * 18;
75565 }
75566 }
75568 {
75569 if (!flag)
75570 {
75571 flag = true;
75572 TileMergeAttemptWeird(num, -1, Main.tileSolid,
ref up,
ref down,
ref left,
ref right,
ref upLeft,
ref upRight,
ref downLeft,
ref downRight);
75574 }
75575 if (num == 2 || num == 23 || num == 60 || num == 70 || num == 109 || num == 199 || num == 477 || num == 492 || num == 633 || num == 661 || num == 662 || Main.tileMoss[num] ||
TileID.
Sets.
tileMossBrick[num])
75576 {
75579 }
75580 if (up == num && down == num && left == num && right == num)
75581 {
75583 {
75585 {
75586 case 0:
75587 rectangle.X = 108;
75588 rectangle.Y = 18;
75589 break;
75590 case 1:
75591 rectangle.X = 126;
75592 rectangle.Y = 18;
75593 break;
75594 default:
75595 rectangle.X = 144;
75596 rectangle.Y = 18;
75597 break;
75598 }
75599 }
75601 {
75603 {
75604 case 0:
75605 rectangle.X = 108;
75606 rectangle.Y = 36;
75607 break;
75608 case 1:
75609 rectangle.X = 126;
75610 rectangle.Y = 36;
75611 break;
75612 default:
75613 rectangle.X = 144;
75614 rectangle.Y = 36;
75615 break;
75616 }
75617 }
75619 {
75621 {
75622 case 0:
75623 rectangle.X = 180;
75624 rectangle.Y = 0;
75625 break;
75626 case 1:
75627 rectangle.X = 180;
75628 rectangle.Y = 18;
75629 break;
75630 default:
75631 rectangle.X = 180;
75632 rectangle.Y = 36;
75633 break;
75634 }
75635 }
75637 {
75639 {
75640 case 0:
75641 rectangle.X = 198;
75642 rectangle.Y = 0;
75643 break;
75644 case 1:
75645 rectangle.X = 198;
75646 rectangle.Y = 18;
75647 break;
75648 default:
75649 rectangle.X = 198;
75650 rectangle.Y = 36;
75651 break;
75652 }
75653 }
75654 else
75655 {
75657 {
75658 case 0:
75659 rectangle.X = 18;
75660 rectangle.Y = 18;
75661 break;
75662 case 1:
75663 rectangle.X = 36;
75664 rectangle.Y = 18;
75665 break;
75666 default:
75667 rectangle.X = 54;
75668 rectangle.Y = 18;
75669 break;
75670 }
75671 }
75672 }
75673 else if (up != num && down == num && left == num && right == num)
75674 {
75676 {
75677 case 0:
75678 rectangle.X = 18;
75679 rectangle.Y = 0;
75680 break;
75681 case 1:
75682 rectangle.X = 36;
75683 rectangle.Y = 0;
75684 break;
75685 default:
75686 rectangle.X = 54;
75687 rectangle.Y = 0;
75688 break;
75689 }
75690 }
75691 else if (up == num && down != num && left == num && right == num)
75692 {
75694 {
75695 case 0:
75696 rectangle.X = 18;
75697 rectangle.Y = 36;
75698 break;
75699 case 1:
75700 rectangle.X = 36;
75701 rectangle.Y = 36;
75702 break;
75703 default:
75704 rectangle.X = 54;
75705 rectangle.Y = 36;
75706 break;
75707 }
75708 }
75709 else if (up == num && down == num && left != num && right == num)
75710 {
75712 {
75713 case 0:
75714 rectangle.X = 0;
75715 rectangle.Y = 0;
75716 break;
75717 case 1:
75718 rectangle.X = 0;
75719 rectangle.Y = 18;
75720 break;
75721 default:
75722 rectangle.X = 0;
75723 rectangle.Y = 36;
75724 break;
75725 }
75726 }
75727 else if (up == num && down == num && left == num && right != num)
75728 {
75730 {
75731 case 0:
75732 rectangle.X = 72;
75733 rectangle.Y = 0;
75734 break;
75735 case 1:
75736 rectangle.X = 72;
75737 rectangle.Y = 18;
75738 break;
75739 default:
75740 rectangle.X = 72;
75741 rectangle.Y = 36;
75742 break;
75743 }
75744 }
75745 else if (up != num && down == num && left != num && right == num)
75746 {
75748 {
75749 case 0:
75750 rectangle.X = 0;
75751 rectangle.Y = 54;
75752 break;
75753 case 1:
75754 rectangle.X = 36;
75755 rectangle.Y = 54;
75756 break;
75757 default:
75758 rectangle.X = 72;
75759 rectangle.Y = 54;
75760 break;
75761 }
75762 }
75763 else if (up != num && down == num && left == num && right != num)
75764 {
75766 {
75767 case 0:
75768 rectangle.X = 18;
75769 rectangle.Y = 54;
75770 break;
75771 case 1:
75772 rectangle.X = 54;
75773 rectangle.Y = 54;
75774 break;
75775 default:
75776 rectangle.X = 90;
75777 rectangle.Y = 54;
75778 break;
75779 }
75780 }
75781 else if (up == num && down != num && left != num && right == num)
75782 {
75784 {
75785 case 0:
75786 rectangle.X = 0;
75787 rectangle.Y = 72;
75788 break;
75789 case 1:
75790 rectangle.X = 36;
75791 rectangle.Y = 72;
75792 break;
75793 default:
75794 rectangle.X = 72;
75795 rectangle.Y = 72;
75796 break;
75797 }
75798 }
75799 else if (up == num && down != num && left == num && right != num)
75800 {
75802 {
75803 case 0:
75804 rectangle.X = 18;
75805 rectangle.Y = 72;
75806 break;
75807 case 1:
75808 rectangle.X = 54;
75809 rectangle.Y = 72;
75810 break;
75811 default:
75812 rectangle.X = 90;
75813 rectangle.Y = 72;
75814 break;
75815 }
75816 }
75817 else if (up == num && down == num && left != num && right != num)
75818 {
75820 {
75821 case 0:
75822 rectangle.X = 90;
75823 rectangle.Y = 0;
75824 break;
75825 case 1:
75826 rectangle.X = 90;
75827 rectangle.Y = 18;
75828 break;
75829 default:
75830 rectangle.X = 90;
75831 rectangle.Y = 36;
75832 break;
75833 }
75834 }
75835 else if (up != num && down != num && left == num && right == num)
75836 {
75838 {
75839 case 0:
75840 rectangle.X = 108;
75841 rectangle.Y = 72;
75842 break;
75843 case 1:
75844 rectangle.X = 126;
75845 rectangle.Y = 72;
75846 break;
75847 default:
75848 rectangle.X = 144;
75849 rectangle.Y = 72;
75850 break;
75851 }
75852 }
75853 else if (up != num && down == num && left != num && right != num)
75854 {
75856 {
75857 case 0:
75858 rectangle.X = 108;
75859 rectangle.Y = 0;
75860 break;
75861 case 1:
75862 rectangle.X = 126;
75863 rectangle.Y = 0;
75864 break;
75865 default:
75866 rectangle.X = 144;
75867 rectangle.Y = 0;
75868 break;
75869 }
75870 }
75871 else if (up == num && down != num && left != num && right != num)
75872 {
75874 {
75875 case 0:
75876 rectangle.X = 108;
75877 rectangle.Y = 54;
75878 break;
75879 case 1:
75880 rectangle.X = 126;
75881 rectangle.Y = 54;
75882 break;
75883 default:
75884 rectangle.X = 144;
75885 rectangle.Y = 54;
75886 break;
75887 }
75888 }
75889 else if (up != num && down != num && left != num && right == num)
75890 {
75892 {
75893 case 0:
75894 rectangle.X = 162;
75895 rectangle.Y = 0;
75896 break;
75897 case 1:
75898 rectangle.X = 162;
75899 rectangle.Y = 18;
75900 break;
75901 default:
75902 rectangle.X = 162;
75903 rectangle.Y = 36;
75904 break;
75905 }
75906 }
75907 else if (up != num && down != num && left == num && right != num)
75908 {
75910 {
75911 case 0:
75912 rectangle.X = 216;
75913 rectangle.Y = 0;
75914 break;
75915 case 1:
75916 rectangle.X = 216;
75917 rectangle.Y = 18;
75918 break;
75919 default:
75920 rectangle.X = 216;
75921 rectangle.Y = 36;
75922 break;
75923 }
75924 }
75925 else if (up != num && down != num && left != num && right != num)
75926 {
75928 {
75929 case 0:
75930 rectangle.X = 162;
75931 rectangle.Y = 54;
75932 break;
75933 case 1:
75934 rectangle.X = 180;
75935 rectangle.Y = 54;
75936 break;
75937 default:
75938 rectangle.X = 198;
75939 rectangle.Y = 54;
75940 break;
75941 }
75942 }
75943 }
75945 {
75947 {
75948 rectangle.X = 18;
75949 rectangle.Y = 18;
75950 }
75951 else if (
num27 == 1)
75952 {
75953 rectangle.X = 36;
75954 rectangle.Y = 18;
75955 }
75957 {
75958 rectangle.X = 54;
75959 rectangle.Y = 18;
75960 }
75961 }
75962 if (Main.tileLargeFrames[num] == 1 &&
num27 == 3)
75963 {
75964 rectangle.Y += 90;
75965 }
75966 if (Main.tileLargeFrames[num] == 2 &&
num27 == 3)
75967 {
75968 rectangle.Y += 90;
75969 }
75973 {
75975 if (num != up)
75976 {
75977 bool num45 = up == 60 || up == 62;
75978 bool num46 = up == 109 || up == 115;
75979 bool flag9 = up == 23 || up == 636 || up == 661;
75980 bool flag10 = up == 199 || up == 205 || up == 662;
75981 bool flag11 = up == 2 || up == 52;
75982 bool flag12 = up == 382;
75983 bool num47 = up == 70 || up == 528;
75984 bool num48 = up == 633 || up == 638;
75987 {
75989 }
75991 {
75993 }
75995 {
75997 }
75999 {
76001 }
76003 {
76005 }
76007 {
76009 }
76010 if (
flag11 && num != 382)
76011 {
76013 }
76015 {
76017 }
76019 {
76022 return;
76023 }
76024 }
76025 if (up != num)
76026 {
76028 if (up == -1)
76029 {
76031 }
76032 if (num == 52 && up != 2 && up != 192)
76033 {
76035 }
76036 if (num == 382 && up != 2 && up != 192)
76037 {
76039 }
76040 if (num == 62 && up != 60)
76041 {
76043 }
76044 if (num == 115 && up != 109)
76045 {
76047 }
76048 if (num == 528 && up != 70)
76049 {
76051 }
76052 if (num == 636 && up != 23 && up != 661)
76053 {
76055 }
76056 if (num == 205 && up != 199 && up != 662)
76057 {
76059 }
76060 if (num == 638 && up != 633)
76061 {
76063 }
76065 {
76067 }
76068 }
76069 }
76072 {
76074 }
76076 {
76079 {
76092 }
76094 }
76096 }
76097 }
76098 }
76100 return;
76101 }
76102 }
76104 }
76105 catch
76106 {
76107 }
76108 if (i > 0 &&
j > 0)
76109 {
76111 }
76112 }
static void Framing_CheckTile(int callX, int callY)
static void Framing_CheckTile(int callX, int callY)
static void Framing_CheckTile(int callX, int callY)
static void Framing_CheckTile(int callX, int callY)
static bool[] MergesWithDirtInASpecialWay
static bool[] GrassSpecial
static bool[] ForcedDirtMerging
static bool[] HasSlopeFrames
static int[] NeedsGrassFramingDirt
static bool[] NeedsGrassFraming
static bool[] ChecksForMerge
static bool[] tileMossBrick
static bool[] JungleSpecial
static bool[] OreMergesWithMud
static bool[] BlockMergesWithMergeAllBlock
static bool[] BasicChestFake
static bool[] MergesWithClouds
static bool[] HellSpecial
static readonly ushort Count
static void CheckRockGolemHead(int x, int y)
static int tileReframeCount
static void Check1xX(int x, int j, short type)
static bool IsTreeType(int tree)
static void Check3x2(int i, int j, int type)
static void Check2x2(int i, int j, int type)
static void CheckTree(int i, int j)
static void Check2xX(int i, int j, ushort type)
static void TileMergeAttemptFrametest(int i, int j, int myType, int lookfor, ref int up, ref int down, ref int left, ref int right, ref int upLeft, ref int upRight, ref int downLeft, ref int downRight)
static void CheckTallGate(int x, int y, int type)
static void Check1x2Top(int x, int j, ushort type)
static void CheckLilyPad(int x, int y)
static void Check6x3(int i, int j, int type)
static void CheckDoorOpen(int i, int j, Tile tileCache)
static bool noLiquidCheck
static void TileMergeAttempt(int myType, int lookfor, ref int up, ref int down, ref int left, ref int right)
static void KillTile(int i, int j, bool fail=false, bool effectOnly=false, bool noItem=false)
static void Check3x3(int i, int j, int type)
static void CheckAlch(int x, int y)
static void CheckBamboo(int x, int y)
static void Check3x2Wall(int x, int y)
static void Check1x1(int x, int y, int type)
static void TileMergeAttemptWeird(int myType, int changeTo, bool[] exclude, ref int up, ref int down, ref int left, ref int right, ref int upLeft, ref int upRight, ref int downLeft, ref int downRight)
static void CheckOrb(int i, int j, int type)
static void Check3x4(int i, int j, int type)
static void CheckCannon(int i, int j, int type)
static void CheckOnTable1x1(int x, int y, int type)
static UnifiedRandom genRand
static void CheckSign(int x, int y, ushort type)
static void Check2x3Wall(int x, int y)
static void Check1x2(int x, int j, ushort type)
static void CheckPot(int i, int j, int type=28)
static void CheckOasisPlant(int i, int j, int type=530)
static void CheckStinkbugBlocker(int x, int y)
static void CheckWoman(int i, int j)
static void CheckLogicTiles(int x, int y, int type)
static void CheckDye(int x, int y)
static void Check3x1(int i, int j, int type)
static void Check5x4(int i, int j, int type)
static void CheckWeaponsRack(int i, int j)
static bool UpdateMapTile(int i, int j, bool addToList=true)
static void CheckDoorClosed(int i, int j, Tile tileCache, int type)
static void CheckChand(int i, int j, int type)
static void CheckChest(int i, int j, int type)
static void Check3x3Wall(int x, int y)
static void Check2x5(int i, int j, int type)
static void Check2x2Style(int i, int j, int type)
static void TileFrame(int i, int j, bool resetFrame=false, bool noBreak=false)
static bool noTileActions
static void Check4x3Wall(int x, int y)
static void Check4x2(int i, int j, int type)
static void CheckTreeWithSettings(int x, int y, CheckTreeSettings settings)
static void Check2x1(int i, int y, ushort type)
static bool SpawnFallingBlockProjectile(int i, int j, Tile tileCache, Tile tileTopCache, Tile tileBottomCache, int type)
static void CheckPalmTree(int i, int j)
static bool SkipFramingBecauseOfGen
static void CheckTrapDoor(int x, int y, int type)
static void CactusFrame(int i, int j)
static void CheckProjectilePressurePad(int i, int j)
static void CheckPile(int i, int y)
static void CheckTight(int x, int j)
static void CheckSuper(int x, int y, int type)
static void CheckSunflower(int i, int j, int type=27)
static int GetTileMossColor(int tileType)
static void Check3x6(int i, int j, int type)
static void CheckGolf1x1(int x, int y, int type)
static void CheckGnome(int x, int j)
static void Check3x5(int i, int j, int type)
static void CheckUnderwaterPlant(ushort type, int x, int y)
static bool SolidTileAllowBottomSlope(int i, int j)
static void CheckTorch(int x, int y)
static bool VanityTreeGroundTest(int tileType)
static bool IsRope(int x, int y)
static void PlantCheck(int x, int y)
static void CheckMB(int i, int j, int type)
static void CheckFoodPlatter(int x, int y, int type)
static void SquareTileFrame(int i, int j, bool resetFrame=true)
static bool GemTreeGroundTest(int tileType)
static void CheckXmasTree(int x, int y)
static void CheckJunglePlant(int i, int j, int type)
static void CheckCatTail(int x, int j)
static void CheckBanner(int x, int j, byte type)
static void CheckMan(int i, int j)
static bool AshTreeGroundTest(int tileType)
static void Check6x4Wall(int x, int y)
1.10.0