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

◆ GetTileDrawData()

void Terraria.GameContent.Drawing.TileDrawing.GetTileDrawData ( int x,
int y,
Tile tileCache,
ushort typeCache,
ref short tileFrameX,
ref short tileFrameY,
out int tileWidth,
out int tileHeight,
out int tileTop,
out int halfBrickHeight,
out int addFrX,
out int addFrY,
out SpriteEffects tileSpriteEffect,
out Texture2D glowTexture,
out Rectangle glowSourceRect,
out Color glowColor )
inlineprivate

Definition at line 3655 of file TileDrawing.cs.

3656 {
3657 tileTop = 0;
3658 tileWidth = 16;
3659 tileHeight = 16;
3660 halfBrickHeight = 0;
3661 addFrY = Main.tileFrame[typeCache] * 38;
3662 addFrX = 0;
3663 tileSpriteEffect = SpriteEffects.None;
3664 glowTexture = null;
3665 glowSourceRect = Rectangle.Empty;
3666 glowColor = Color.Transparent;
3667 Color color = Lighting.GetColor(x, y);
3668 switch (typeCache)
3669 {
3670 case 443:
3671 if (tileFrameX / 36 >= 2)
3672 {
3673 tileTop = -2;
3674 }
3675 else
3676 {
3677 tileTop = 2;
3678 }
3679 break;
3680 case 571:
3681 if (x % 2 == 0)
3682 {
3683 tileSpriteEffect = SpriteEffects.FlipHorizontally;
3684 }
3685 tileTop = 2;
3686 break;
3687 case 136:
3688 if (tileFrameX == 0)
3689 {
3690 tileTop = 2;
3691 }
3692 break;
3693 case 561:
3694 tileTop -= 2;
3695 tileHeight = 20;
3696 addFrY = tileFrameY / 18 * 4;
3697 break;
3698 case 518:
3699 {
3700 int num27 = tileCache.liquid / 16;
3701 num27 -= 3;
3702 if (WorldGen.SolidTile(x, y - 1) && num27 > 8)
3703 {
3704 num27 = 8;
3705 }
3706 if (tileCache.liquid == 0)
3707 {
3708 Tile tileSafely = Framing.GetTileSafely(x, y + 1);
3709 if (tileSafely.nactive())
3710 {
3711 switch (tileSafely.blockType())
3712 {
3713 case 1:
3714 num27 = -16 + Math.Max(8, tileSafely.liquid / 16);
3715 break;
3716 case 2:
3717 case 3:
3718 num27 -= 4;
3719 break;
3720 }
3721 }
3722 }
3723 tileTop -= num27;
3724 break;
3725 }
3726 case 330:
3727 case 331:
3728 case 332:
3729 case 333:
3730 tileTop += 2;
3731 break;
3732 case 129:
3733 addFrY = 0;
3734 if (tileFrameX >= 324)
3735 {
3736 int num22 = (tileFrameX - 324) / 18;
3737 int num23 = (num22 + Main.tileFrame[typeCache]) % 6 - num22;
3738 addFrX = num23 * 18;
3739 }
3740 break;
3741 case 5:
3742 {
3743 tileWidth = 20;
3744 tileHeight = 20;
3745 int treeBiome = GetTreeBiome(x, y, tileFrameX, tileFrameY);
3746 tileFrameX += (short)(176 * (treeBiome + 1));
3747 break;
3748 }
3749 case 583:
3750 case 584:
3751 case 585:
3752 case 586:
3753 case 587:
3754 case 588:
3755 case 589:
3756 case 596:
3757 case 616:
3758 case 634:
3759 tileWidth = 20;
3760 tileHeight = 20;
3761 break;
3762 case 476:
3763 tileWidth = 20;
3764 tileHeight = 18;
3765 break;
3766 case 323:
3767 {
3768 tileWidth = 20;
3769 tileHeight = 20;
3770 int palmTreeBiome = GetPalmTreeBiome(x, y);
3771 tileFrameY = (short)(22 * palmTreeBiome);
3772 break;
3773 }
3774 case 4:
3775 tileWidth = 20;
3776 tileHeight = 20;
3777 if (WorldGen.SolidTile(x, y - 1))
3778 {
3779 tileTop = 4;
3780 }
3781 break;
3782 case 78:
3783 case 85:
3784 case 100:
3785 case 133:
3786 case 134:
3787 case 173:
3788 case 210:
3789 case 233:
3790 case 254:
3791 case 283:
3792 case 378:
3793 case 457:
3794 case 466:
3795 case 520:
3796 case 651:
3797 case 652:
3798 tileTop = 2;
3799 break;
3800 case 530:
3801 {
3802 int num48 = y - tileFrameY % 36 / 18 + 2;
3803 int num49 = x - tileFrameX % 54 / 18;
3804 WorldGen.GetBiomeInfluence(num49, num49 + 3, num48, num48, out var corruptCount2, out var crimsonCount2, out var hallowedCount2);
3805 int num50 = corruptCount2;
3806 if (num50 < crimsonCount2)
3807 {
3808 num50 = crimsonCount2;
3809 }
3810 if (num50 < hallowedCount2)
3811 {
3812 num50 = hallowedCount2;
3813 }
3814 int num51 = 0;
3815 num51 = ((corruptCount2 != 0 || crimsonCount2 != 0 || hallowedCount2 != 0) ? ((hallowedCount2 == num50) ? 1 : ((crimsonCount2 != num50) ? 3 : 2)) : 0);
3816 addFrY += 36 * num51;
3817 tileTop = 2;
3818 break;
3819 }
3820 case 485:
3821 {
3822 tileTop = 2;
3823 int num39 = Main.tileFrameCounter[typeCache];
3824 num39 /= 5;
3825 int num40 = y - tileFrameY / 18;
3826 int num41 = x - tileFrameX / 18;
3827 num39 += num40 + num41;
3828 num39 %= 4;
3829 addFrY = num39 * 36;
3830 break;
3831 }
3832 case 489:
3833 {
3834 tileTop = 2;
3835 int num28 = y - tileFrameY / 18;
3836 int num29 = x - tileFrameX / 18;
3837 if (InAPlaceWithWind(num29, num28, 2, 3))
3838 {
3839 int num30 = Main.tileFrameCounter[typeCache];
3840 num30 /= 5;
3841 num30 += num28 + num29;
3842 num30 %= 16;
3843 addFrY = num30 * 54;
3844 }
3845 break;
3846 }
3847 case 490:
3848 {
3849 tileTop = 2;
3850 int y2 = y - tileFrameY / 18;
3851 int x2 = x - tileFrameX / 18;
3852 bool num24 = InAPlaceWithWind(x2, y2, 2, 2);
3853 int num25 = (num24 ? Main.tileFrame[typeCache] : 0);
3854 int num26 = 0;
3855 if (num24)
3856 {
3857 if (Math.Abs(Main.WindForVisuals) > 0.5f)
3858 {
3859 switch (Main.weatherVaneBobframe)
3860 {
3861 case 0:
3862 num26 = 0;
3863 break;
3864 case 1:
3865 num26 = 1;
3866 break;
3867 case 2:
3868 num26 = 2;
3869 break;
3870 case 3:
3871 num26 = 1;
3872 break;
3873 case 4:
3874 num26 = 0;
3875 break;
3876 case 5:
3877 num26 = -1;
3878 break;
3879 case 6:
3880 num26 = -2;
3881 break;
3882 case 7:
3883 num26 = -1;
3884 break;
3885 }
3886 }
3887 else
3888 {
3889 switch (Main.weatherVaneBobframe)
3890 {
3891 case 0:
3892 num26 = 0;
3893 break;
3894 case 1:
3895 num26 = 1;
3896 break;
3897 case 2:
3898 num26 = 0;
3899 break;
3900 case 3:
3901 num26 = -1;
3902 break;
3903 case 4:
3904 num26 = 0;
3905 break;
3906 case 5:
3907 num26 = 1;
3908 break;
3909 case 6:
3910 num26 = 0;
3911 break;
3912 case 7:
3913 num26 = -1;
3914 break;
3915 }
3916 }
3917 }
3918 num25 += num26;
3919 if (num25 < 0)
3920 {
3921 num25 += 12;
3922 }
3923 num25 %= 12;
3924 addFrY = num25 * 36;
3925 break;
3926 }
3927 case 33:
3928 case 49:
3929 case 174:
3930 case 372:
3931 case 646:
3932 tileHeight = 20;
3933 tileTop = -4;
3934 break;
3935 case 529:
3936 {
3937 int num18 = y + 1;
3938 WorldGen.GetBiomeInfluence(x, x, num18, num18, out var corruptCount, out var crimsonCount, out var hallowedCount);
3939 int num19 = corruptCount;
3940 if (num19 < crimsonCount)
3941 {
3942 num19 = crimsonCount;
3943 }
3944 if (num19 < hallowedCount)
3945 {
3946 num19 = hallowedCount;
3947 }
3948 int num20 = 0;
3949 num20 = ((corruptCount == 0 && crimsonCount == 0 && hallowedCount == 0) ? ((x < WorldGen.beachDistance || x > Main.maxTilesX - WorldGen.beachDistance) ? 1 : 0) : ((hallowedCount == num19) ? 2 : ((crimsonCount != num19) ? 4 : 3)));
3950 addFrY += 34 * num20 - tileFrameY;
3951 tileHeight = 32;
3952 tileTop = -14;
3953 if (x % 2 == 0)
3954 {
3955 tileSpriteEffect = SpriteEffects.FlipHorizontally;
3956 }
3957 break;
3958 }
3959 case 3:
3960 case 24:
3961 case 61:
3962 case 71:
3963 case 110:
3964 case 201:
3965 case 637:
3966 tileHeight = 20;
3967 if (x % 2 == 0)
3968 {
3969 tileSpriteEffect = SpriteEffects.FlipHorizontally;
3970 }
3971 break;
3972 case 20:
3973 case 590:
3974 case 595:
3975 tileHeight = 18;
3976 if (x % 2 == 0)
3977 {
3978 tileSpriteEffect = SpriteEffects.FlipHorizontally;
3979 }
3980 break;
3981 case 615:
3982 tileHeight = 18;
3983 if (x % 2 == 0)
3984 {
3985 tileSpriteEffect = SpriteEffects.FlipHorizontally;
3986 }
3987 break;
3988 case 16:
3989 case 17:
3990 case 18:
3991 case 26:
3992 case 32:
3993 case 69:
3994 case 72:
3995 case 77:
3996 case 79:
3997 case 124:
3998 case 137:
3999 case 138:
4000 case 352:
4001 case 462:
4002 case 487:
4003 case 488:
4004 case 574:
4005 case 575:
4006 case 576:
4007 case 577:
4008 case 578:
4009 case 664:
4010 tileHeight = 18;
4011 break;
4012 case 654:
4013 tileTop += 2;
4014 break;
4015 case 14:
4016 case 21:
4017 case 411:
4018 case 467:
4019 case 469:
4020 if (tileFrameY == 18)
4021 {
4022 tileHeight = 18;
4023 }
4024 break;
4025 case 15:
4026 case 497:
4027 if (tileFrameY % 40 == 18)
4028 {
4029 tileHeight = 18;
4030 }
4031 break;
4032 case 172:
4033 case 376:
4034 if (tileFrameY % 38 == 18)
4035 {
4036 tileHeight = 18;
4037 }
4038 break;
4039 case 27:
4040 if (tileFrameY % 74 == 54)
4041 {
4042 tileHeight = 18;
4043 }
4044 break;
4045 case 132:
4046 case 135:
4047 tileTop = 2;
4048 tileHeight = 18;
4049 break;
4050 case 82:
4051 case 83:
4052 case 84:
4053 tileHeight = 20;
4054 tileTop = -2;
4055 if (x % 2 == 0)
4056 {
4057 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4058 }
4059 break;
4060 case 324:
4061 tileWidth = 20;
4062 tileHeight = 20;
4063 tileTop = -2;
4064 if (x % 2 == 0)
4065 {
4066 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4067 }
4068 break;
4069 case 494:
4070 tileTop = 2;
4071 break;
4072 case 52:
4073 case 62:
4074 case 115:
4075 case 205:
4076 case 382:
4077 case 528:
4078 case 636:
4079 case 638:
4080 tileTop = -2;
4081 if (x % 2 == 0)
4082 {
4083 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4084 }
4085 break;
4086 case 80:
4087 case 142:
4088 case 143:
4089 tileTop = 2;
4090 break;
4091 case 139:
4092 {
4093 tileTop = 2;
4094 int num31 = tileFrameY / 2016;
4095 addFrY -= 2016 * num31;
4096 addFrX += 72 * num31;
4097 break;
4098 }
4099 case 73:
4100 case 74:
4101 case 113:
4102 tileTop = -12;
4103 tileHeight = 32;
4104 if (x % 2 == 0)
4105 {
4106 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4107 }
4108 break;
4109 case 388:
4110 case 389:
4111 {
4112 TileObjectData.GetTileData(typeCache, tileFrameX / 18);
4113 int num17 = 94;
4114 tileTop = -2;
4115 if (tileFrameY == num17 - 20 || tileFrameY == num17 * 2 - 20 || tileFrameY == 0 || tileFrameY == num17)
4116 {
4117 tileHeight = 18;
4118 }
4119 if (tileFrameY != 0 && tileFrameY != num17)
4120 {
4121 tileTop = 0;
4122 }
4123 break;
4124 }
4125 case 227:
4126 tileWidth = 32;
4127 tileHeight = 38;
4128 if (tileFrameX == 238)
4129 {
4130 tileTop -= 6;
4131 }
4132 else
4133 {
4134 tileTop -= 20;
4135 }
4136 if (tileFrameX == 204)
4137 {
4138 WorldGen.GetCactusType(x, y, tileFrameX, tileFrameY, out var evil, out var good, out var crimson);
4139 if (good)
4140 {
4141 tileFrameX += 238;
4142 }
4143 if (evil)
4144 {
4145 tileFrameX += 204;
4146 }
4147 if (crimson)
4148 {
4149 tileFrameX += 272;
4150 }
4151 }
4152 if (x % 2 == 0)
4153 {
4154 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4155 }
4156 break;
4157 case 624:
4158 tileWidth = 20;
4159 tileHeight = 16;
4160 tileTop += 2;
4161 if (x % 2 == 0)
4162 {
4163 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4164 }
4165 break;
4166 case 656:
4167 tileWidth = 24;
4168 tileHeight = 34;
4169 tileTop -= 16;
4170 if (x % 2 == 0)
4171 {
4172 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4173 }
4174 break;
4175 case 579:
4176 {
4177 tileWidth = 20;
4178 tileHeight = 20;
4179 tileTop -= 2;
4180 bool flag = (float)(x * 16 + 8) > Main.LocalPlayer.Center.X;
4181 if (tileFrameX > 0)
4182 {
4183 if (flag)
4184 {
4185 addFrY = 22;
4186 }
4187 else
4188 {
4189 addFrY = 0;
4190 }
4191 }
4192 else if (flag)
4193 {
4194 addFrY = 0;
4195 }
4196 else
4197 {
4198 addFrY = 22;
4199 }
4200 break;
4201 }
4202 case 567:
4203 tileWidth = 26;
4204 tileHeight = 18;
4205 if (tileFrameY == 0)
4206 {
4207 tileTop = -2;
4208 }
4209 if (x % 2 == 0)
4210 {
4211 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4212 }
4213 break;
4214 case 185:
4215 case 186:
4216 case 187:
4217 tileTop = 2;
4218 switch (typeCache)
4219 {
4220 case 185:
4221 if (tileFrameY == 18 && tileFrameX >= 576 && tileFrameX <= 882)
4222 {
4223 Main.tileShine2[185] = true;
4224 }
4225 else
4226 {
4227 Main.tileShine2[185] = false;
4228 }
4229 if (tileFrameY == 18)
4230 {
4231 int num37 = tileFrameX / 1908;
4232 addFrX -= 1908 * num37;
4233 addFrY += 18 * num37;
4234 }
4235 break;
4236 case 186:
4237 if (tileFrameX >= 864 && tileFrameX <= 1170)
4238 {
4239 Main.tileShine2[186] = true;
4240 }
4241 else
4242 {
4243 Main.tileShine2[186] = false;
4244 }
4245 break;
4246 case 187:
4247 {
4248 int num36 = tileFrameX / 1890;
4249 addFrX -= 1890 * num36;
4250 addFrY += 36 * num36;
4251 break;
4252 }
4253 }
4254 break;
4255 case 650:
4256 tileTop = 2;
4257 break;
4258 case 649:
4259 {
4260 tileTop = 2;
4261 int num35 = tileFrameX / 1908;
4262 addFrX -= 1908 * num35;
4263 addFrY += 18 * num35;
4264 break;
4265 }
4266 case 647:
4267 tileTop = 2;
4268 break;
4269 case 648:
4270 {
4271 tileTop = 2;
4272 int num34 = tileFrameX / 1890;
4273 addFrX -= 1890 * num34;
4274 addFrY += 36 * num34;
4275 break;
4276 }
4277 case 178:
4278 if (tileFrameY <= 36)
4279 {
4280 tileTop = 2;
4281 }
4282 break;
4283 case 184:
4284 tileWidth = 20;
4285 if (tileFrameY <= 36)
4286 {
4287 tileTop = 2;
4288 }
4289 else if (tileFrameY <= 108)
4290 {
4291 tileTop = -2;
4292 }
4293 break;
4294 case 519:
4295 tileTop = 2;
4296 if (x % 2 == 0)
4297 {
4298 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4299 }
4300 break;
4301 case 493:
4302 if (tileFrameY == 0)
4303 {
4304 int num13 = Main.tileFrameCounter[typeCache];
4305 float num14 = Math.Abs(Main.WindForVisuals);
4306 int num15 = y - tileFrameY / 18;
4307 int num16 = x - tileFrameX / 18;
4308 if (!InAPlaceWithWind(x, num15, 1, 1))
4309 {
4310 num14 = 0f;
4311 }
4312 if (!(num14 < 0.1f))
4313 {
4314 if (num14 < 0.5f)
4315 {
4316 num13 /= 20;
4317 num13 += num15 + num16;
4318 num13 %= 6;
4319 num13 = ((!(Main.WindForVisuals < 0f)) ? (num13 + 1) : (6 - num13));
4320 addFrY = num13 * 36;
4321 }
4322 else
4323 {
4324 num13 /= 10;
4325 num13 += num15 + num16;
4326 num13 %= 6;
4327 num13 = ((!(Main.WindForVisuals < 0f)) ? (num13 + 7) : (12 - num13));
4328 addFrY = num13 * 36;
4329 }
4330 }
4331 }
4332 tileTop = 2;
4333 break;
4334 case 28:
4335 case 105:
4336 case 470:
4337 case 475:
4338 case 506:
4339 case 547:
4340 case 548:
4341 case 552:
4342 case 560:
4343 case 597:
4344 case 613:
4345 case 621:
4346 case 622:
4347 case 623:
4348 case 653:
4349 tileTop = 2;
4350 break;
4351 case 617:
4352 tileTop = 2;
4353 tileFrameY %= 144;
4354 tileFrameX %= 54;
4355 break;
4356 case 614:
4357 addFrX = Main.tileFrame[typeCache] * 54;
4358 addFrY = 0;
4359 tileTop = 2;
4360 break;
4361 case 81:
4362 tileTop -= 8;
4363 tileHeight = 26;
4364 tileWidth = 24;
4365 if (x % 2 == 0)
4366 {
4367 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4368 }
4369 break;
4370 case 272:
4371 addFrY = 0;
4372 break;
4373 case 106:
4374 addFrY = Main.tileFrame[typeCache] * 54;
4375 break;
4376 case 300:
4377 case 301:
4378 case 302:
4379 case 303:
4380 case 304:
4381 case 305:
4382 case 306:
4383 case 307:
4384 case 308:
4385 case 354:
4386 case 355:
4387 case 499:
4388 addFrY = Main.tileFrame[typeCache] * 54;
4389 tileTop = 2;
4390 break;
4391 case 377:
4392 addFrY = Main.tileFrame[typeCache] * 38;
4393 tileTop = 2;
4394 break;
4395 case 463:
4396 case 464:
4397 addFrY = Main.tileFrame[typeCache] * 72;
4398 tileTop = 2;
4399 break;
4400 case 491:
4401 tileTop = 2;
4402 addFrX = 54;
4403 break;
4404 case 379:
4405 addFrY = Main.tileFrame[typeCache] * 90;
4406 break;
4407 case 349:
4408 {
4409 tileTop = 2;
4410 int num6 = tileFrameX % 36;
4411 int num7 = tileFrameY % 54;
4412 if (Animation.GetTemporaryFrame(x - num6 / 18, y - num7 / 18, out var frameData2))
4413 {
4414 tileFrameX = (short)(36 * frameData2 + num6);
4415 }
4416 break;
4417 }
4418 case 441:
4419 case 468:
4420 {
4421 if (tileFrameY == 18)
4422 {
4423 tileHeight = 18;
4424 }
4425 int num3 = tileFrameX % 36;
4426 int num4 = tileFrameY % 38;
4427 if (Animation.GetTemporaryFrame(x - num3 / 18, y - num4 / 18, out var frameData))
4428 {
4429 tileFrameY = (short)(38 * frameData + num4);
4430 }
4431 break;
4432 }
4433 case 390:
4434 addFrY = Main.tileFrame[typeCache] * 36;
4435 break;
4436 case 412:
4437 addFrY = 0;
4438 tileTop = 2;
4439 break;
4440 case 406:
4441 {
4442 tileHeight = 16;
4443 if (tileFrameY % 54 >= 36)
4444 {
4445 tileHeight = 18;
4446 }
4447 int num53 = Main.tileFrame[typeCache];
4448 if (tileFrameY >= 108)
4449 {
4450 num53 = 6 - tileFrameY / 54;
4451 }
4452 else if (tileFrameY >= 54)
4453 {
4454 num53 = Main.tileFrame[typeCache] - 1;
4455 }
4456 addFrY = num53 * 56;
4457 addFrY += tileFrameY / 54 * 2;
4458 break;
4459 }
4460 case 452:
4461 {
4462 int num52 = Main.tileFrame[typeCache];
4463 if (tileFrameX >= 54)
4464 {
4465 num52 = 0;
4466 }
4467 addFrY = num52 * 54;
4468 break;
4469 }
4470 case 455:
4471 {
4472 addFrY = 0;
4473 tileTop = 2;
4474 int num47 = 1 + Main.tileFrame[typeCache];
4475 if (!BirthdayParty.PartyIsUp)
4476 {
4477 num47 = 0;
4478 }
4479 addFrY = num47 * 54;
4480 break;
4481 }
4482 case 454:
4483 addFrY = Main.tileFrame[typeCache] * 54;
4484 break;
4485 case 453:
4486 {
4487 int num45 = Main.tileFrameCounter[typeCache];
4488 num45 /= 20;
4489 int num46 = y - tileFrameY / 18;
4490 num45 += num46 + x;
4491 num45 %= 3;
4492 addFrY = num45 * 54;
4493 break;
4494 }
4495 case 456:
4496 {
4497 int num42 = Main.tileFrameCounter[typeCache];
4498 num42 /= 20;
4499 int num43 = y - tileFrameY / 18;
4500 int num44 = x - tileFrameX / 18;
4501 num42 += num43 + num44;
4502 num42 %= 4;
4503 addFrY = num42 * 54;
4504 break;
4505 }
4506 case 405:
4507 {
4508 tileHeight = 16;
4509 if (tileFrameY > 0)
4510 {
4511 tileHeight = 18;
4512 }
4513 int num38 = Main.tileFrame[typeCache];
4514 if (tileFrameX >= 54)
4515 {
4516 num38 = 0;
4517 }
4518 addFrY = num38 * 38;
4519 break;
4520 }
4521 case 12:
4522 case 31:
4523 case 96:
4524 case 639:
4525 case 665:
4526 addFrY = Main.tileFrame[typeCache] * 36;
4527 break;
4528 case 238:
4529 tileTop = 2;
4530 addFrY = Main.tileFrame[typeCache] * 36;
4531 break;
4532 case 593:
4533 {
4534 if (tileFrameX >= 18)
4535 {
4536 addFrX = -18;
4537 }
4538 tileTop = 2;
4539 if (Animation.GetTemporaryFrame(x, y, out var frameData4))
4540 {
4541 addFrY = (short)(18 * frameData4);
4542 }
4543 else if (tileFrameX < 18)
4544 {
4545 addFrY = Main.tileFrame[typeCache] * 18;
4546 }
4547 else
4548 {
4549 addFrY = 0;
4550 }
4551 break;
4552 }
4553 case 594:
4554 {
4555 if (tileFrameX >= 36)
4556 {
4557 addFrX = -36;
4558 }
4559 tileTop = 2;
4560 int num32 = tileFrameX % 36;
4561 int num33 = tileFrameY % 36;
4562 if (Animation.GetTemporaryFrame(x - num32 / 18, y - num33 / 18, out var frameData3))
4563 {
4564 addFrY = (short)(36 * frameData3);
4565 }
4566 else if (tileFrameX < 36)
4567 {
4568 addFrY = Main.tileFrame[typeCache] * 36;
4569 }
4570 else
4571 {
4572 addFrY = 0;
4573 }
4574 break;
4575 }
4576 case 215:
4577 if (tileFrameY < 36)
4578 {
4579 addFrY = Main.tileFrame[typeCache] * 36;
4580 }
4581 else
4582 {
4583 addFrY = 252;
4584 }
4585 tileTop = 2;
4586 break;
4587 case 592:
4588 addFrY = Main.tileFrame[typeCache] * 54;
4589 break;
4590 case 228:
4591 case 231:
4592 case 243:
4593 case 247:
4594 tileTop = 2;
4595 addFrY = Main.tileFrame[typeCache] * 54;
4596 break;
4597 case 244:
4598 tileTop = 2;
4599 if (tileFrameX < 54)
4600 {
4601 addFrY = Main.tileFrame[typeCache] * 36;
4602 }
4603 else
4604 {
4605 addFrY = 0;
4606 }
4607 break;
4608 case 565:
4609 tileTop = 2;
4610 if (tileFrameX < 36)
4611 {
4612 addFrY = Main.tileFrame[typeCache] * 36;
4613 }
4614 else
4615 {
4616 addFrY = 0;
4617 }
4618 break;
4619 case 235:
4620 addFrY = Main.tileFrame[typeCache] * 18;
4621 break;
4622 case 217:
4623 case 218:
4624 case 564:
4625 addFrY = Main.tileFrame[typeCache] * 36;
4626 tileTop = 2;
4627 break;
4628 case 219:
4629 case 220:
4630 case 642:
4631 addFrY = Main.tileFrame[typeCache] * 54;
4632 tileTop = 2;
4633 break;
4634 case 270:
4635 case 271:
4636 case 581:
4637 {
4638 int num21 = Main.tileFrame[typeCache] + x % 6;
4639 if (x % 2 == 0)
4640 {
4641 num21 += 3;
4642 }
4643 if (x % 3 == 0)
4644 {
4645 num21 += 3;
4646 }
4647 if (x % 4 == 0)
4648 {
4649 num21 += 3;
4650 }
4651 while (num21 > 5)
4652 {
4653 num21 -= 6;
4654 }
4655 addFrX = num21 * 18;
4656 addFrY = 0;
4657 if (x % 2 == 0)
4658 {
4659 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4660 }
4661 break;
4662 }
4663 case 660:
4664 {
4665 int num12 = Main.tileFrame[typeCache] + x % 5;
4666 if (x % 2 == 0)
4667 {
4668 num12 += 3;
4669 }
4670 if (x % 3 == 0)
4671 {
4672 num12 += 3;
4673 }
4674 if (x % 4 == 0)
4675 {
4676 num12 += 3;
4677 }
4678 while (num12 > 4)
4679 {
4680 num12 -= 5;
4681 }
4682 addFrX = num12 * 18;
4683 addFrY = 0;
4684 if (x % 2 == 0)
4685 {
4686 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4687 }
4688 break;
4689 }
4690 case 572:
4691 {
4692 int num11;
4693 for (num11 = Main.tileFrame[typeCache] + x % 4; num11 > 3; num11 -= 4)
4694 {
4695 }
4696 addFrX = num11 * 18;
4697 addFrY = 0;
4698 if (x % 2 == 0)
4699 {
4700 tileSpriteEffect = SpriteEffects.FlipHorizontally;
4701 }
4702 break;
4703 }
4704 case 428:
4705 tileTop += 4;
4706 if (PressurePlateHelper.PressurePlatesPressed.ContainsKey(new Point(x, y)))
4707 {
4708 addFrX += 18;
4709 }
4710 break;
4711 case 442:
4712 tileWidth = 20;
4713 tileHeight = 20;
4714 switch (tileFrameX / 22)
4715 {
4716 case 1:
4717 tileTop = -4;
4718 break;
4719 case 2:
4720 tileTop = -2;
4721 tileWidth = 24;
4722 break;
4723 case 3:
4724 tileTop = -2;
4725 break;
4726 }
4727 break;
4728 case 426:
4729 case 430:
4730 case 431:
4731 case 432:
4732 case 433:
4733 case 434:
4734 addFrY = 90;
4735 break;
4736 case 275:
4737 case 276:
4738 case 277:
4739 case 278:
4740 case 279:
4741 case 280:
4742 case 281:
4743 case 296:
4744 case 297:
4745 case 309:
4746 case 358:
4747 case 359:
4748 case 413:
4749 case 414:
4750 case 542:
4751 case 550:
4752 case 551:
4753 case 553:
4754 case 554:
4755 case 558:
4756 case 559:
4757 case 599:
4758 case 600:
4759 case 601:
4760 case 602:
4761 case 603:
4762 case 604:
4763 case 605:
4764 case 606:
4765 case 607:
4766 case 608:
4767 case 609:
4768 case 610:
4769 case 611:
4770 case 612:
4771 case 632:
4772 case 640:
4773 case 643:
4774 case 644:
4775 case 645:
4776 {
4777 tileTop = 2;
4778 Main.critterCage = true;
4779 int bigAnimalCageFrame = GetBigAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4780 switch (typeCache)
4781 {
4782 case 275:
4783 case 359:
4784 case 599:
4785 case 600:
4786 case 601:
4787 case 602:
4788 case 603:
4789 case 604:
4790 case 605:
4791 addFrY = Main.bunnyCageFrame[bigAnimalCageFrame] * 54;
4792 break;
4793 case 550:
4794 case 551:
4795 addFrY = Main.turtleCageFrame[bigAnimalCageFrame] * 54;
4796 break;
4797 case 542:
4798 addFrY = Main.owlCageFrame[bigAnimalCageFrame] * 54;
4799 break;
4800 case 276:
4801 case 413:
4802 case 414:
4803 case 606:
4804 case 607:
4805 case 608:
4806 case 609:
4807 case 610:
4808 case 611:
4809 case 612:
4810 addFrY = Main.squirrelCageFrame[bigAnimalCageFrame] * 54;
4811 break;
4812 case 277:
4813 addFrY = Main.mallardCageFrame[bigAnimalCageFrame] * 54;
4814 break;
4815 case 278:
4816 addFrY = Main.duckCageFrame[bigAnimalCageFrame] * 54;
4817 break;
4818 case 553:
4819 addFrY = Main.grebeCageFrame[bigAnimalCageFrame] * 54;
4820 break;
4821 case 554:
4822 addFrY = Main.seagullCageFrame[bigAnimalCageFrame] * 54;
4823 break;
4824 case 279:
4825 case 358:
4826 addFrY = Main.birdCageFrame[bigAnimalCageFrame] * 54;
4827 break;
4828 case 280:
4829 addFrY = Main.blueBirdCageFrame[bigAnimalCageFrame] * 54;
4830 break;
4831 case 281:
4832 addFrY = Main.redBirdCageFrame[bigAnimalCageFrame] * 54;
4833 break;
4834 case 632:
4835 case 640:
4836 case 643:
4837 case 644:
4838 case 645:
4839 addFrY = Main.macawCageFrame[bigAnimalCageFrame] * 54;
4840 break;
4841 case 296:
4842 case 297:
4843 addFrY = Main.scorpionCageFrame[0, bigAnimalCageFrame] * 54;
4844 break;
4845 case 309:
4846 addFrY = Main.penguinCageFrame[bigAnimalCageFrame] * 54;
4847 break;
4848 case 558:
4849 case 559:
4850 addFrY = Main.seahorseCageFrame[bigAnimalCageFrame] * 54;
4851 break;
4852 }
4853 break;
4854 }
4855 case 285:
4856 case 286:
4857 case 298:
4858 case 299:
4859 case 310:
4860 case 339:
4861 case 361:
4862 case 362:
4863 case 363:
4864 case 364:
4865 case 391:
4866 case 392:
4867 case 393:
4868 case 394:
4869 case 532:
4870 case 533:
4871 case 538:
4872 case 544:
4873 case 555:
4874 case 556:
4875 case 582:
4876 case 619:
4877 case 629:
4878 {
4879 tileTop = 2;
4880 Main.critterCage = true;
4881 int smallAnimalCageFrame2 = GetSmallAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4882 switch (typeCache)
4883 {
4884 case 285:
4885 addFrY = Main.snailCageFrame[smallAnimalCageFrame2] * 36;
4886 break;
4887 case 286:
4888 case 582:
4889 addFrY = Main.snail2CageFrame[smallAnimalCageFrame2] * 36;
4890 break;
4891 case 298:
4892 case 361:
4893 addFrY = Main.frogCageFrame[smallAnimalCageFrame2] * 36;
4894 break;
4895 case 339:
4896 case 362:
4897 addFrY = Main.grasshopperCageFrame[smallAnimalCageFrame2] * 36;
4898 break;
4899 case 299:
4900 case 363:
4901 addFrY = Main.mouseCageFrame[smallAnimalCageFrame2] * 36;
4902 break;
4903 case 310:
4904 case 364:
4905 case 391:
4906 case 619:
4907 addFrY = Main.wormCageFrame[smallAnimalCageFrame2] * 36;
4908 break;
4909 case 392:
4910 case 393:
4911 case 394:
4912 addFrY = Main.slugCageFrame[typeCache - 392, smallAnimalCageFrame2] * 36;
4913 break;
4914 case 532:
4915 addFrY = Main.maggotCageFrame[smallAnimalCageFrame2] * 36;
4916 break;
4917 case 533:
4918 addFrY = Main.ratCageFrame[smallAnimalCageFrame2] * 36;
4919 break;
4920 case 538:
4921 case 544:
4922 case 629:
4923 addFrY = Main.ladybugCageFrame[smallAnimalCageFrame2] * 36;
4924 break;
4925 case 555:
4926 case 556:
4927 addFrY = Main.waterStriderCageFrame[smallAnimalCageFrame2] * 36;
4928 break;
4929 }
4930 break;
4931 }
4932 case 282:
4933 case 505:
4934 case 543:
4935 {
4936 tileTop = 2;
4937 Main.critterCage = true;
4938 int waterAnimalCageFrame5 = GetWaterAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4939 addFrY = Main.fishBowlFrame[waterAnimalCageFrame5] * 36;
4940 break;
4941 }
4942 case 598:
4943 {
4944 tileTop = 2;
4945 Main.critterCage = true;
4946 int waterAnimalCageFrame4 = GetWaterAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4947 addFrY = Main.lavaFishBowlFrame[waterAnimalCageFrame4] * 36;
4948 break;
4949 }
4950 case 568:
4951 case 569:
4952 case 570:
4953 {
4954 tileTop = 2;
4955 Main.critterCage = true;
4956 int waterAnimalCageFrame3 = GetWaterAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4957 addFrY = Main.fairyJarFrame[waterAnimalCageFrame3] * 36;
4958 break;
4959 }
4960 case 288:
4961 case 289:
4962 case 290:
4963 case 291:
4964 case 292:
4965 case 293:
4966 case 294:
4967 case 295:
4968 case 360:
4969 case 580:
4970 case 620:
4971 {
4972 tileTop = 2;
4973 Main.critterCage = true;
4974 int waterAnimalCageFrame2 = GetWaterAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4975 int num10 = typeCache - 288;
4976 if (typeCache == 360 || typeCache == 580 || typeCache == 620)
4977 {
4978 num10 = 8;
4979 }
4980 addFrY = Main.butterflyCageFrame[num10, waterAnimalCageFrame2] * 36;
4981 break;
4982 }
4983 case 521:
4984 case 522:
4985 case 523:
4986 case 524:
4987 case 525:
4988 case 526:
4989 case 527:
4990 {
4991 tileTop = 2;
4992 Main.critterCage = true;
4993 int waterAnimalCageFrame = GetWaterAnimalCageFrame(x, y, tileFrameX, tileFrameY);
4994 int num9 = typeCache - 521;
4995 addFrY = Main.dragonflyJarFrame[num9, waterAnimalCageFrame] * 36;
4996 break;
4997 }
4998 case 316:
4999 case 317:
5000 case 318:
5001 {
5002 tileTop = 2;
5003 Main.critterCage = true;
5004 int smallAnimalCageFrame = GetSmallAnimalCageFrame(x, y, tileFrameX, tileFrameY);
5005 int num8 = typeCache - 316;
5006 addFrY = Main.jellyfishCageFrame[num8, smallAnimalCageFrame] * 36;
5007 break;
5008 }
5009 case 207:
5010 tileTop = 2;
5011 if (tileFrameY >= 72)
5012 {
5013 addFrY = Main.tileFrame[typeCache];
5014 int num5 = x;
5015 if (tileFrameX % 36 != 0)
5016 {
5017 num5--;
5018 }
5019 addFrY += num5 % 6;
5020 if (addFrY >= 6)
5021 {
5022 addFrY -= 6;
5023 }
5024 addFrY *= 72;
5025 }
5026 else
5027 {
5028 addFrY = 0;
5029 }
5030 break;
5031 case 410:
5032 if (tileFrameY == 36)
5033 {
5034 tileHeight = 18;
5035 }
5036 if (tileFrameY >= 56)
5037 {
5038 addFrY = Main.tileFrame[typeCache];
5039 addFrY *= 56;
5040 }
5041 else
5042 {
5043 addFrY = 0;
5044 }
5045 break;
5046 case 480:
5047 case 509:
5048 case 657:
5049 tileTop = 2;
5050 if (tileFrameY >= 54)
5051 {
5052 addFrY = Main.tileFrame[typeCache];
5053 addFrY *= 54;
5054 }
5055 else
5056 {
5057 addFrY = 0;
5058 }
5059 break;
5060 case 658:
5061 tileTop = 2;
5062 switch (tileFrameY / 54)
5063 {
5064 default:
5065 addFrY = Main.tileFrame[typeCache];
5066 addFrY *= 54;
5067 break;
5068 case 1:
5069 addFrY = Main.tileFrame[typeCache];
5070 addFrY *= 54;
5071 addFrY += 486;
5072 break;
5073 case 2:
5074 addFrY = Main.tileFrame[typeCache];
5075 addFrY *= 54;
5076 addFrY += 972;
5077 break;
5078 }
5079 break;
5080 case 326:
5081 case 327:
5082 case 328:
5083 case 329:
5084 case 345:
5085 case 351:
5086 case 421:
5087 case 422:
5088 case 458:
5089 case 459:
5090 addFrY = Main.tileFrame[typeCache] * 90;
5091 break;
5092 case 541:
5093 addFrY = ((!_shouldShowInvisibleBlocks) ? 90 : 0);
5094 break;
5095 case 507:
5096 case 508:
5097 {
5098 int num = 20;
5099 int num2 = (Main.tileFrameCounter[typeCache] + x * 11 + y * 27) % (num * 8);
5100 addFrY = 90 * (num2 / num);
5101 break;
5102 }
5103 case 336:
5104 case 340:
5105 case 341:
5106 case 342:
5107 case 343:
5108 case 344:
5109 addFrY = Main.tileFrame[typeCache] * 90;
5110 tileTop = 2;
5111 break;
5112 case 89:
5113 tileTop = 2;
5114 break;
5115 case 102:
5116 tileTop = 2;
5117 break;
5118 }
5119 if (tileCache.halfBrick())
5120 {
5121 halfBrickHeight = 8;
5122 }
5123 switch (typeCache)
5124 {
5125 case 657:
5126 if (tileFrameY >= 54)
5127 {
5128 glowTexture = TextureAssets.GlowMask[330].Value;
5129 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5130 glowColor = Color.White;
5131 }
5132 break;
5133 case 656:
5134 glowTexture = TextureAssets.GlowMask[329].Value;
5135 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5136 glowColor = new Color(255, 255, 255, 0) * ((float)(int)Main.mouseTextColor / 255f);
5137 break;
5138 case 634:
5139 glowTexture = TextureAssets.GlowMask[315].Value;
5140 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5141 glowColor = Color.White;
5142 break;
5143 case 637:
5144 glowTexture = TextureAssets.Tile[637].Value;
5145 glowSourceRect = new Rectangle(tileFrameX + addFrX, tileFrameY + addFrY, tileWidth, tileHeight);
5146 glowColor = Color.Lerp(Color.White, color, 0.75f);
5147 break;
5148 case 638:
5149 glowTexture = TextureAssets.GlowMask[327].Value;
5150 glowSourceRect = new Rectangle(tileFrameX + addFrX, tileFrameY + addFrY, tileWidth, tileHeight - halfBrickHeight);
5151 glowColor = Color.Lerp(Color.White, color, 0.75f);
5152 break;
5153 case 568:
5154 glowTexture = TextureAssets.GlowMask[268].Value;
5155 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5156 glowColor = Color.White;
5157 break;
5158 case 569:
5159 glowTexture = TextureAssets.GlowMask[269].Value;
5160 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5161 glowColor = Color.White;
5162 break;
5163 case 570:
5164 glowTexture = TextureAssets.GlowMask[270].Value;
5165 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5166 glowColor = Color.White;
5167 break;
5168 case 580:
5169 glowTexture = TextureAssets.GlowMask[289].Value;
5170 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5171 glowColor = new Color(225, 110, 110, 0);
5172 break;
5173 case 564:
5174 if (tileCache.frameX < 36)
5175 {
5176 glowTexture = TextureAssets.GlowMask[267].Value;
5177 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5178 glowColor = new Color(200, 200, 200, 0) * ((float)(int)Main.mouseTextColor / 255f);
5179 }
5180 addFrY = 0;
5181 break;
5182 case 184:
5183 if (tileCache.frameX == 110)
5184 {
5185 glowTexture = TextureAssets.GlowMask[127].Value;
5186 glowSourceRect = new Rectangle(tileFrameX, tileFrameY, tileWidth, tileHeight);
5187 glowColor = _lavaMossGlow;
5188 }
5189 if (tileCache.frameX == 132)
5190 {
5191 glowTexture = TextureAssets.GlowMask[127].Value;
5192 glowSourceRect = new Rectangle(tileFrameX, tileFrameY, tileWidth, tileHeight);
5193 glowColor = _kryptonMossGlow;
5194 }
5195 if (tileCache.frameX == 154)
5196 {
5197 glowTexture = TextureAssets.GlowMask[127].Value;
5198 glowSourceRect = new Rectangle(tileFrameX, tileFrameY, tileWidth, tileHeight);
5199 glowColor = _xenonMossGlow;
5200 }
5201 if (tileCache.frameX == 176)
5202 {
5203 glowTexture = TextureAssets.GlowMask[127].Value;
5204 glowSourceRect = new Rectangle(tileFrameX, tileFrameY, tileWidth, tileHeight);
5205 glowColor = _argonMossGlow;
5206 }
5207 if (tileCache.frameX == 198)
5208 {
5209 glowTexture = TextureAssets.GlowMask[127].Value;
5210 glowSourceRect = new Rectangle(tileFrameX, tileFrameY, tileWidth, tileHeight);
5211 glowColor = _violetMossGlow;
5212 }
5213 if (tileCache.frameX == 220)
5214 {
5215 glowTexture = TextureAssets.GlowMask[127].Value;
5216 glowSourceRect = new Rectangle(tileFrameX, tileFrameY, tileWidth, tileHeight);
5217 glowColor = new Color(Main.DiscoR, Main.DiscoG, Main.DiscoB);
5218 }
5219 break;
5220 case 463:
5221 glowTexture = TextureAssets.GlowMask[243].Value;
5222 glowSourceRect = new Rectangle(tileFrameX, tileFrameY + addFrY, tileWidth, tileHeight);
5223 glowColor = new Color(127, 127, 127, 0);
5224 break;
5225 case 19:
5226 {
5227 int num73 = tileFrameY / 18;
5228 if (num73 == 26)
5229 {
5230 glowTexture = TextureAssets.GlowMask[65].Value;
5231 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 18, tileWidth, tileHeight);
5232 glowColor = _martianGlow;
5233 }
5234 if (num73 == 27)
5235 {
5236 glowTexture = TextureAssets.GlowMask[112].Value;
5237 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 18, tileWidth, tileHeight);
5238 glowColor = _meteorGlow;
5239 }
5240 break;
5241 }
5242 case 90:
5243 {
5244 int num67 = tileFrameY / 36;
5245 if (num67 == 27)
5246 {
5247 glowTexture = TextureAssets.GlowMask[52].Value;
5248 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 36, tileWidth, tileHeight);
5249 glowColor = _martianGlow;
5250 }
5251 if (num67 == 28)
5252 {
5253 glowTexture = TextureAssets.GlowMask[113].Value;
5254 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 36, tileWidth, tileHeight);
5255 glowColor = _meteorGlow;
5256 }
5257 break;
5258 }
5259 case 79:
5260 {
5261 int num63 = tileFrameY / 36;
5262 if (num63 == 27)
5263 {
5264 glowTexture = TextureAssets.GlowMask[53].Value;
5265 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 36, tileWidth, tileHeight);
5266 glowColor = _martianGlow;
5267 }
5268 if (num63 == 28)
5269 {
5270 glowTexture = TextureAssets.GlowMask[114].Value;
5271 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 36, tileWidth, tileHeight);
5272 glowColor = _meteorGlow;
5273 }
5274 break;
5275 }
5276 case 89:
5277 {
5278 int num56 = tileFrameX / 54;
5279 int num57 = tileFrameX / 1998;
5280 addFrX -= 1998 * num57;
5281 addFrY += 36 * num57;
5282 if (num56 == 29)
5283 {
5284 glowTexture = TextureAssets.GlowMask[66].Value;
5285 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5286 glowColor = _martianGlow;
5287 }
5288 if (num56 == 30)
5289 {
5290 glowTexture = TextureAssets.GlowMask[123].Value;
5291 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5292 glowColor = _meteorGlow;
5293 }
5294 break;
5295 }
5296 case 100:
5297 if (tileFrameX / 36 == 0 && tileFrameY / 36 == 27)
5298 {
5299 glowTexture = TextureAssets.GlowMask[68].Value;
5300 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 36, tileWidth, tileHeight);
5301 glowColor = _martianGlow;
5302 }
5303 break;
5304 case 33:
5305 if (tileFrameX / 18 == 0 && tileFrameY / 22 == 26)
5306 {
5307 glowTexture = TextureAssets.GlowMask[61].Value;
5308 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 22, tileWidth, tileHeight);
5309 glowColor = _martianGlow;
5310 }
5311 break;
5312 case 15:
5313 {
5314 int num70 = tileFrameY / 40;
5315 if (num70 == 32)
5316 {
5317 glowTexture = TextureAssets.GlowMask[54].Value;
5318 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 40, tileWidth, tileHeight);
5319 glowColor = _martianGlow;
5320 }
5321 if (num70 == 33)
5322 {
5323 glowTexture = TextureAssets.GlowMask[116].Value;
5324 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 40, tileWidth, tileHeight);
5325 glowColor = _meteorGlow;
5326 }
5327 break;
5328 }
5329 case 34:
5330 if (tileFrameX / 54 == 0 && tileFrameY / 54 == 33)
5331 {
5332 glowTexture = TextureAssets.GlowMask[55].Value;
5333 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 54, tileWidth, tileHeight);
5334 glowColor = _martianGlow;
5335 }
5336 break;
5337 case 21:
5338 case 467:
5339 {
5340 int num62 = tileFrameX / 36;
5341 if (num62 == 48)
5342 {
5343 glowTexture = TextureAssets.GlowMask[56].Value;
5344 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5345 glowColor = _martianGlow;
5346 }
5347 if (num62 == 49)
5348 {
5349 glowTexture = TextureAssets.GlowMask[117].Value;
5350 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5351 glowColor = _meteorGlow;
5352 }
5353 break;
5354 }
5355 case 441:
5356 case 468:
5357 {
5358 int num58 = tileFrameX / 36;
5359 if (num58 == 48)
5360 {
5361 glowTexture = TextureAssets.GlowMask[56].Value;
5362 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5363 glowColor = _martianGlow;
5364 }
5365 if (num58 == 49)
5366 {
5367 glowTexture = TextureAssets.GlowMask[117].Value;
5368 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5369 glowColor = _meteorGlow;
5370 }
5371 break;
5372 }
5373 case 10:
5374 if (tileFrameY / 54 == 32)
5375 {
5376 glowTexture = TextureAssets.GlowMask[57].Value;
5377 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 54, tileWidth, tileHeight);
5378 glowColor = _martianGlow;
5379 }
5380 break;
5381 case 11:
5382 {
5383 int num74 = tileFrameY / 54;
5384 if (num74 == 32)
5385 {
5386 glowTexture = TextureAssets.GlowMask[58].Value;
5387 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 54, tileWidth, tileHeight);
5388 glowColor = _martianGlow;
5389 }
5390 if (num74 == 33)
5391 {
5392 glowTexture = TextureAssets.GlowMask[119].Value;
5393 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 54, tileWidth, tileHeight);
5394 glowColor = _meteorGlow;
5395 }
5396 break;
5397 }
5398 case 88:
5399 {
5400 int num71 = tileFrameX / 54;
5401 int num72 = tileFrameX / 1998;
5402 addFrX -= 1998 * num72;
5403 addFrY += 36 * num72;
5404 if (num71 == 24)
5405 {
5406 glowTexture = TextureAssets.GlowMask[59].Value;
5407 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5408 glowColor = _martianGlow;
5409 }
5410 if (num71 == 25)
5411 {
5412 glowTexture = TextureAssets.GlowMask[120].Value;
5413 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5414 glowColor = _meteorGlow;
5415 }
5416 break;
5417 }
5418 case 42:
5419 if (tileFrameY / 36 == 33)
5420 {
5421 glowTexture = TextureAssets.GlowMask[63].Value;
5422 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 36, tileWidth, tileHeight);
5423 glowColor = _martianGlow;
5424 }
5425 break;
5426 case 87:
5427 {
5428 int num68 = tileFrameX / 54;
5429 int num69 = tileFrameX / 1998;
5430 addFrX -= 1998 * num69;
5431 addFrY += 36 * num69;
5432 if (num68 == 26)
5433 {
5434 glowTexture = TextureAssets.GlowMask[64].Value;
5435 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5436 glowColor = _martianGlow;
5437 }
5438 if (num68 == 27)
5439 {
5440 glowTexture = TextureAssets.GlowMask[121].Value;
5441 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5442 glowColor = _meteorGlow;
5443 }
5444 break;
5445 }
5446 case 14:
5447 {
5448 int num66 = tileFrameX / 54;
5449 if (num66 == 31)
5450 {
5451 glowTexture = TextureAssets.GlowMask[67].Value;
5452 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5453 glowColor = _martianGlow;
5454 }
5455 if (num66 == 32)
5456 {
5457 glowTexture = TextureAssets.GlowMask[124].Value;
5458 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5459 glowColor = _meteorGlow;
5460 }
5461 break;
5462 }
5463 case 93:
5464 {
5465 int num64 = tileFrameY / 54;
5466 int num65 = tileFrameY / 1998;
5467 addFrY -= 1998 * num65;
5468 addFrX += 36 * num65;
5469 tileTop += 2;
5470 if (num64 == 27)
5471 {
5472 glowTexture = TextureAssets.GlowMask[62].Value;
5473 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 54, tileWidth, tileHeight);
5474 glowColor = _martianGlow;
5475 }
5476 break;
5477 }
5478 case 18:
5479 {
5480 int num61 = tileFrameX / 36;
5481 if (num61 == 27)
5482 {
5483 glowTexture = TextureAssets.GlowMask[69].Value;
5484 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5485 glowColor = _martianGlow;
5486 }
5487 if (num61 == 28)
5488 {
5489 glowTexture = TextureAssets.GlowMask[125].Value;
5490 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5491 glowColor = _meteorGlow;
5492 }
5493 break;
5494 }
5495 case 101:
5496 {
5497 int num59 = tileFrameX / 54;
5498 int num60 = tileFrameX / 1998;
5499 addFrX -= 1998 * num60;
5500 addFrY += 72 * num60;
5501 if (num59 == 28)
5502 {
5503 glowTexture = TextureAssets.GlowMask[60].Value;
5504 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5505 glowColor = _martianGlow;
5506 }
5507 if (num59 == 29)
5508 {
5509 glowTexture = TextureAssets.GlowMask[115].Value;
5510 glowSourceRect = new Rectangle(tileFrameX % 54, tileFrameY, tileWidth, tileHeight);
5511 glowColor = _meteorGlow;
5512 }
5513 break;
5514 }
5515 case 104:
5516 {
5517 int num55 = tileFrameX / 36;
5518 tileTop = 2;
5519 if (num55 == 24)
5520 {
5521 glowTexture = TextureAssets.GlowMask[51].Value;
5522 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5523 glowColor = _martianGlow;
5524 }
5525 if (num55 == 25)
5526 {
5527 glowTexture = TextureAssets.GlowMask[118].Value;
5528 glowSourceRect = new Rectangle(tileFrameX % 36, tileFrameY, tileWidth, tileHeight);
5529 glowColor = _meteorGlow;
5530 }
5531 break;
5532 }
5533 case 172:
5534 {
5535 int num54 = tileFrameY / 38;
5536 if (num54 == 28)
5537 {
5538 glowTexture = TextureAssets.GlowMask[88].Value;
5539 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 38, tileWidth, tileHeight);
5540 glowColor = _martianGlow;
5541 }
5542 if (num54 == 29)
5543 {
5544 glowTexture = TextureAssets.GlowMask[122].Value;
5545 glowSourceRect = new Rectangle(tileFrameX, tileFrameY % 38, tileWidth, tileHeight);
5546 glowColor = _meteorGlow;
5547 }
5548 break;
5549 }
5550 }
5551 }
System.Math.Abs
static double Abs(double value)
System.Math.Max
static byte Max(byte val1, byte val2)
Definition Math.cs:738
Terraria.GameContent.Drawing.TileDrawing.GetBigAnimalCageFrame
int GetBigAnimalCageFrame(int x, int y, int tileFrameX, int tileFrameY)
Definition TileDrawing.cs:5585
Terraria.GameContent.Drawing.TileDrawing.GetPalmTreeBiome
int GetPalmTreeBiome(int tileX, int tileY)
Definition TileDrawing.cs:1431
Terraria.GameContent.Drawing.TileDrawing.GetSmallAnimalCageFrame
int GetSmallAnimalCageFrame(int x, int y, int tileFrameX, int tileFrameY)
Definition TileDrawing.cs:5578
Terraria.GameContent.Drawing.TileDrawing.GetWaterAnimalCageFrame
int GetWaterAnimalCageFrame(int x, int y, int tileFrameX, int tileFrameY)
Definition TileDrawing.cs:5571
Terraria.GameContent.Drawing.TileDrawing.GetTreeBiome
static int GetTreeBiome(int tileX, int tileY, int tileFrameX, int tileFrameY)
Definition TileDrawing.cs:1440
Terraria.GameContent.Drawing.TileDrawing.InAPlaceWithWind
bool InAPlaceWithWind(int x, int y, int width, int height)
Definition TileDrawing.cs:3650
Terraria.ObjectData.TileObjectData.GetTileData
static TileObjectData GetTileData(int type, int style, int alternate=0)
Definition TileObjectData.cs:4366
Microsoft.Xna.Framework.Color.Transparent
static Color Transparent
Definition Color.cs:76
Microsoft.Xna.Framework.Color.Lerp
static Color Lerp(Color value1, Color value2, float amount)
Definition Color.cs:491

References Terraria.GameContent.Drawing.TileDrawing._argonMossGlow, Terraria.GameContent.Drawing.TileDrawing._kryptonMossGlow, Terraria.GameContent.Drawing.TileDrawing._lavaMossGlow, Terraria.GameContent.Drawing.TileDrawing._martianGlow, Terraria.GameContent.Drawing.TileDrawing._meteorGlow, Terraria.GameContent.Drawing.TileDrawing._shouldShowInvisibleBlocks, Terraria.GameContent.Drawing.TileDrawing._violetMossGlow, Terraria.GameContent.Drawing.TileDrawing._xenonMossGlow, System.Math.Abs(), Terraria.WorldGen.beachDistance, Terraria.Main.birdCageFrame, Terraria.Main.blueBirdCageFrame, Terraria.Main.bunnyCageFrame, Terraria.Main.butterflyCageFrame, Microsoft.Xna.Framework.Graphics.Color, Terraria.Main.DiscoB, Terraria.Main.DiscoG, Terraria.Main.DiscoR, Terraria.Main.dragonflyJarFrame, Terraria.Main.duckCageFrame, Microsoft.Xna.Framework.Rectangle.Empty, Terraria.Main.fairyJarFrame, Terraria.Main.fishBowlFrame, Terraria.Tile.frameX, Terraria.Main.frogCageFrame, Terraria.GameContent.Drawing.TileDrawing.GetBigAnimalCageFrame(), Terraria.WorldGen.GetBiomeInfluence(), Terraria.WorldGen.GetCactusType(), Terraria.Lighting.GetColor(), Terraria.GameContent.Drawing.TileDrawing.GetPalmTreeBiome(), Terraria.GameContent.Drawing.TileDrawing.GetSmallAnimalCageFrame(), Terraria.Animation.GetTemporaryFrame(), Terraria.ObjectData.TileObjectData.GetTileData(), Terraria.Framing.GetTileSafely(), Terraria.GameContent.Drawing.TileDrawing.GetTreeBiome(), Terraria.GameContent.Drawing.TileDrawing.GetWaterAnimalCageFrame(), Terraria.GameContent.TextureAssets.GlowMask, Terraria.Main.grasshopperCageFrame, Terraria.Main.grebeCageFrame, Terraria.Tile.halfBrick(), Terraria.GameContent.Drawing.TileDrawing.InAPlaceWithWind(), Terraria.Main.jellyfishCageFrame, Terraria.Main.ladybugCageFrame, Terraria.Main.lavaFishBowlFrame, Microsoft.Xna.Framework.Color.Lerp(), Terraria.Tile.liquid, Terraria.Main.LocalPlayer, Terraria.Main.macawCageFrame, Terraria.Main.maggotCageFrame, Terraria.Main.mallardCageFrame, System.Math.Max(), Terraria.Main.maxTilesX, Terraria.Main.mouseCageFrame, Terraria.Main.owlCageFrame, Terraria.GameContent.Events.BirthdayParty.PartyIsUp, Terraria.Main.penguinCageFrame, Terraria.GameContent.PressurePlateHelper.PressurePlatesPressed, Terraria.Main.ratCageFrame, Terraria.Main.redBirdCageFrame, Terraria.Main.scorpionCageFrame, Terraria.Main.seagullCageFrame, Terraria.Main.seahorseCageFrame, Terraria.Main.slugCageFrame, Terraria.Main.snail2CageFrame, Terraria.Main.snailCageFrame, Terraria.WorldGen.SolidTile(), Terraria.Main.squirrelCageFrame, Terraria.GameContent.TextureAssets.Tile, Terraria.Main.tileFrame, Terraria.Main.tileFrameCounter, Terraria.Main.tileShine2, Microsoft.Xna.Framework.Color.Transparent, Terraria.Main.turtleCageFrame, Terraria.Main.waterStriderCageFrame, Terraria.Main.weatherVaneBobframe, Microsoft.Xna.Framework.Color.White, Terraria.Main.WindForVisuals, and Terraria.Main.wormCageFrame.

Referenced by Terraria.GameContent.Drawing.TileDrawing.DrawAnyDirectionalGrass(), Terraria.GameContent.Drawing.TileDrawing.DrawGrass(), Terraria.GameContent.Drawing.TileDrawing.DrawMultiTileGrassInWind(), Terraria.GameContent.Drawing.TileDrawing.DrawMultiTileVinesInWind(), Terraria.GameContent.Drawing.TileDrawing.DrawRisingVineStrip(), Terraria.GameContent.Drawing.TileDrawing.DrawSingleTile(), and Terraria.GameContent.Drawing.TileDrawing.DrawVineStrip().