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

◆ AnimateTiles_CritterCages()

static void Terraria.Main.AnimateTiles_CritterCages ( )
inlinestatic

Definition at line 12552 of file Main.cs.

12553 {
12554 if (!critterCage)
12555 {
12556 return;
12557 }
12558 for (int i = 0; i < cageFrames; i++)
12559 {
12560 if (bunnyCageFrame[i] == 0)
12561 {
12563 if (bunnyCageFrameCounter[i] <= rand.Next(30, 900))
12564 {
12565 continue;
12566 }
12567 if (rand.Next(3) != 0)
12568 {
12569 int num = rand.Next(7);
12570 if (num == 0)
12571 {
12572 bunnyCageFrame[i] = 4;
12573 }
12574 else if (num <= 2)
12575 {
12576 bunnyCageFrame[i] = 2;
12577 }
12578 else
12579 {
12580 bunnyCageFrame[i] = 1;
12581 }
12582 }
12584 }
12585 else if (bunnyCageFrame[i] == 1)
12586 {
12588 if (bunnyCageFrameCounter[i] >= 10)
12589 {
12591 bunnyCageFrame[i] = 0;
12592 }
12593 }
12594 else if (bunnyCageFrame[i] >= 2 && bunnyCageFrame[i] <= 3)
12595 {
12597 if (bunnyCageFrameCounter[i] >= 10)
12598 {
12600 bunnyCageFrame[i]++;
12601 }
12602 if (bunnyCageFrame[i] > 3)
12603 {
12604 bunnyCageFrame[i] = 0;
12605 }
12606 }
12607 else if (bunnyCageFrame[i] >= 4 && bunnyCageFrame[i] <= 10)
12608 {
12610 if (bunnyCageFrameCounter[i] >= 5)
12611 {
12613 bunnyCageFrame[i]++;
12614 }
12615 }
12616 else if (bunnyCageFrame[i] == 11)
12617 {
12619 if (bunnyCageFrameCounter[i] <= rand.Next(30, 900))
12620 {
12621 continue;
12622 }
12623 if (rand.Next(3) != 0)
12624 {
12625 if (rand.Next(7) == 0)
12626 {
12627 bunnyCageFrame[i] = 13;
12628 }
12629 else
12630 {
12631 bunnyCageFrame[i] = 12;
12632 }
12633 }
12635 }
12636 else if (bunnyCageFrame[i] == 12)
12637 {
12639 if (bunnyCageFrameCounter[i] >= 10)
12640 {
12642 bunnyCageFrame[i] = 11;
12643 }
12644 }
12645 else if (bunnyCageFrame[i] >= 13)
12646 {
12648 if (bunnyCageFrameCounter[i] >= 5)
12649 {
12651 bunnyCageFrame[i]++;
12652 }
12653 if (bunnyCageFrame[i] > 21)
12654 {
12655 bunnyCageFrame[i] = 0;
12656 }
12657 }
12658 }
12659 for (int j = 0; j < cageFrames; j++)
12660 {
12661 if (squirrelCageFrame[j] == 0)
12662 {
12664 if (squirrelCageFrameCounter[j] <= rand.Next(30, 900))
12665 {
12666 continue;
12667 }
12668 if (rand.Next(3) != 0)
12669 {
12670 int num = rand.Next(7);
12671 if (num == 0)
12672 {
12673 squirrelCageFrame[j] = 4;
12674 }
12675 else if (num <= 2)
12676 {
12677 squirrelCageFrame[j] = 2;
12678 }
12679 else
12680 {
12681 squirrelCageFrame[j] = 1;
12682 }
12683 }
12685 }
12686 else if (squirrelCageFrame[j] == 1)
12687 {
12689 if (squirrelCageFrameCounter[j] >= 10)
12690 {
12692 squirrelCageFrame[j] = 0;
12693 }
12694 }
12695 else if (squirrelCageFrame[j] >= 2 && squirrelCageFrame[j] <= 3)
12696 {
12698 if (squirrelCageFrameCounter[j] >= 5)
12699 {
12702 }
12703 if (squirrelCageFrame[j] > 3)
12704 {
12705 if (rand.Next(5) == 0)
12706 {
12707 squirrelCageFrame[j] = 0;
12708 }
12709 else
12710 {
12711 squirrelCageFrame[j] = 2;
12712 }
12713 }
12714 }
12715 else if (squirrelCageFrame[j] >= 4 && squirrelCageFrame[j] <= 8)
12716 {
12718 if (squirrelCageFrameCounter[j] >= 5)
12719 {
12722 }
12723 }
12724 else if (squirrelCageFrame[j] == 9)
12725 {
12727 if (squirrelCageFrameCounter[j] <= rand.Next(30, 900))
12728 {
12729 continue;
12730 }
12731 if (rand.Next(3) != 0)
12732 {
12733 int num = rand.Next(7);
12734 if (num == 0)
12735 {
12736 squirrelCageFrame[j] = 13;
12737 }
12738 else if (num <= 2)
12739 {
12740 squirrelCageFrame[j] = 11;
12741 }
12742 else
12743 {
12744 squirrelCageFrame[j] = 10;
12745 }
12746 }
12748 }
12749 else if (squirrelCageFrame[j] == 10)
12750 {
12752 if (squirrelCageFrameCounter[j] >= 10)
12753 {
12755 squirrelCageFrame[j] = 9;
12756 }
12757 }
12758 else if (squirrelCageFrame[j] == 11 || squirrelCageFrame[j] == 12)
12759 {
12761 if (squirrelCageFrameCounter[j] < 5)
12762 {
12763 continue;
12764 }
12766 if (squirrelCageFrame[j] > 12)
12767 {
12768 if (rand.Next(5) != 0)
12769 {
12770 squirrelCageFrame[j] = 11;
12771 }
12772 else
12773 {
12774 squirrelCageFrame[j] = 9;
12775 }
12776 }
12778 }
12779 else if (squirrelCageFrame[j] >= 13)
12780 {
12782 if (squirrelCageFrameCounter[j] >= 5)
12783 {
12786 }
12787 if (squirrelCageFrame[j] > 17)
12788 {
12789 squirrelCageFrame[j] = 0;
12790 }
12791 }
12792 }
12793 for (int k = 0; k < cageFrames; k++)
12794 {
12795 if (squirrelCageFrameOrange[k] == 0)
12796 {
12798 if (squirrelCageFrameCounterOrange[k] <= rand.Next(30, 900))
12799 {
12800 continue;
12801 }
12802 if (rand.Next(3) != 0)
12803 {
12804 int num = rand.Next(7);
12805 if (num == 0)
12806 {
12808 }
12809 else if (num <= 2)
12810 {
12812 }
12813 else
12814 {
12816 }
12817 }
12819 }
12820 else if (squirrelCageFrameOrange[k] == 1)
12821 {
12824 {
12827 }
12828 }
12829 else if (squirrelCageFrameOrange[k] >= 2 && squirrelCageFrameOrange[k] <= 3)
12830 {
12833 {
12836 }
12837 if (squirrelCageFrameOrange[k] > 3)
12838 {
12839 if (rand.Next(5) == 0)
12840 {
12842 }
12843 else
12844 {
12846 }
12847 }
12848 }
12849 else if (squirrelCageFrameOrange[k] >= 4 && squirrelCageFrameOrange[k] <= 8)
12850 {
12853 {
12856 }
12857 }
12858 else if (squirrelCageFrameOrange[k] == 9)
12859 {
12861 if (squirrelCageFrameCounterOrange[k] <= rand.Next(30, 900))
12862 {
12863 continue;
12864 }
12865 if (rand.Next(3) != 0)
12866 {
12867 int num = rand.Next(7);
12868 if (num == 0)
12869 {
12871 }
12872 else if (num <= 2)
12873 {
12875 }
12876 else
12877 {
12879 }
12880 }
12882 }
12883 else if (squirrelCageFrameOrange[k] == 10)
12884 {
12887 {
12890 }
12891 }
12892 else if (squirrelCageFrameOrange[k] == 11 || squirrelCageFrameOrange[k] == 12)
12893 {
12896 {
12897 continue;
12898 }
12900 if (squirrelCageFrameOrange[k] > 12)
12901 {
12902 if (rand.Next(5) != 0)
12903 {
12905 }
12906 else
12907 {
12909 }
12910 }
12912 }
12913 else if (squirrelCageFrameOrange[k] >= 13)
12914 {
12917 {
12920 }
12921 if (squirrelCageFrameOrange[k] > 17)
12922 {
12924 }
12925 }
12926 }
12927 for (int l = 0; l < cageFrames; l++)
12928 {
12929 if (mallardCageFrame[l] == 0 || mallardCageFrame[l] == 4)
12930 {
12932 if (mallardCageFrameCounter[l] <= rand.Next(45, 2700))
12933 {
12934 continue;
12935 }
12936 if ((mallardCageFrame[l] == 0 && rand.Next(3) != 0) || (mallardCageFrame[l] == 4 && rand.Next(5) == 0))
12937 {
12938 if (rand.Next(6) == 0)
12939 {
12940 mallardCageFrame[l] = 5;
12941 }
12942 else if (rand.Next(3) == 0)
12943 {
12944 if (mallardCageFrame[l] == 4)
12945 {
12946 mallardCageFrame[l] = 0;
12947 }
12948 else
12949 {
12950 mallardCageFrame[l] = 4;
12951 }
12952 }
12953 else
12954 {
12955 mallardCageFrame[l] = 1;
12956 }
12957 }
12959 }
12960 else if (mallardCageFrame[l] >= 1 && mallardCageFrame[l] <= 3)
12961 {
12963 if (mallardCageFrameCounter[l] >= 5)
12964 {
12967 }
12968 if (mallardCageFrame[l] > 3)
12969 {
12970 if (rand.Next(5) == 0)
12971 {
12972 mallardCageFrame[l] = 0;
12973 }
12974 else
12975 {
12976 mallardCageFrame[l] = 1;
12977 }
12978 }
12979 }
12980 else if (mallardCageFrame[l] >= 5 && mallardCageFrame[l] <= 11)
12981 {
12983 if (mallardCageFrameCounter[l] >= 5)
12984 {
12987 }
12988 }
12989 else if (mallardCageFrame[l] == 12 || mallardCageFrame[l] == 16)
12990 {
12992 if (mallardCageFrameCounter[l] <= rand.Next(45, 2700))
12993 {
12994 continue;
12995 }
12996 if ((mallardCageFrame[l] == 12 && rand.Next(3) != 0) || (mallardCageFrame[l] == 16 && rand.Next(5) == 0))
12997 {
12998 if (rand.Next(6) == 0)
12999 {
13000 mallardCageFrame[l] = 17;
13001 }
13002 else if (rand.Next(3) == 0)
13003 {
13004 if (mallardCageFrame[l] == 16)
13005 {
13006 mallardCageFrame[l] = 12;
13007 }
13008 else
13009 {
13010 mallardCageFrame[l] = 16;
13011 }
13012 }
13013 else
13014 {
13015 mallardCageFrame[l] = 13;
13016 }
13017 }
13019 }
13020 else if (mallardCageFrame[l] >= 13 && mallardCageFrame[l] <= 15)
13021 {
13023 if (mallardCageFrameCounter[l] < 5)
13024 {
13025 continue;
13026 }
13028 if (mallardCageFrame[l] > 15)
13029 {
13030 if (rand.Next(5) != 0)
13031 {
13032 mallardCageFrame[l] = 12;
13033 }
13034 else
13035 {
13036 mallardCageFrame[l] = 13;
13037 }
13038 }
13040 }
13041 else if (mallardCageFrame[l] >= 17)
13042 {
13044 if (mallardCageFrameCounter[l] >= 5)
13045 {
13048 }
13049 if (mallardCageFrame[l] > 23)
13050 {
13051 mallardCageFrame[l] = 0;
13052 }
13053 }
13054 }
13055 for (int m = 0; m < cageFrames; m++)
13056 {
13057 if (duckCageFrame[m] == 0 || duckCageFrame[m] == 4)
13058 {
13060 if (duckCageFrameCounter[m] <= rand.Next(45, 2700))
13061 {
13062 continue;
13063 }
13064 if ((duckCageFrame[m] == 0 && rand.Next(3) != 0) || (duckCageFrame[m] == 4 && rand.Next(5) == 0))
13065 {
13066 if (rand.Next(6) == 0)
13067 {
13068 duckCageFrame[m] = 5;
13069 }
13070 else if (rand.Next(3) == 0)
13071 {
13072 if (duckCageFrame[m] == 4)
13073 {
13074 duckCageFrame[m] = 0;
13075 }
13076 else
13077 {
13078 duckCageFrame[m] = 4;
13079 }
13080 }
13081 else
13082 {
13083 duckCageFrame[m] = 1;
13084 }
13085 }
13087 }
13088 else if (duckCageFrame[m] >= 1 && duckCageFrame[m] <= 3)
13089 {
13091 if (duckCageFrameCounter[m] >= 5)
13092 {
13094 duckCageFrame[m]++;
13095 }
13096 if (duckCageFrame[m] > 3)
13097 {
13098 if (rand.Next(5) == 0)
13099 {
13100 duckCageFrame[m] = 0;
13101 }
13102 else
13103 {
13104 duckCageFrame[m] = 1;
13105 }
13106 }
13107 }
13108 else if (duckCageFrame[m] >= 5 && duckCageFrame[m] <= 11)
13109 {
13111 if (duckCageFrameCounter[m] >= 5)
13112 {
13114 duckCageFrame[m]++;
13115 }
13116 }
13117 else if (duckCageFrame[m] == 12 || duckCageFrame[m] == 16)
13118 {
13120 if (duckCageFrameCounter[m] <= rand.Next(45, 2700))
13121 {
13122 continue;
13123 }
13124 if ((duckCageFrame[m] == 12 && rand.Next(3) != 0) || (duckCageFrame[m] == 16 && rand.Next(5) == 0))
13125 {
13126 if (rand.Next(6) == 0)
13127 {
13128 duckCageFrame[m] = 17;
13129 }
13130 else if (rand.Next(3) == 0)
13131 {
13132 if (duckCageFrame[m] == 16)
13133 {
13134 duckCageFrame[m] = 12;
13135 }
13136 else
13137 {
13138 duckCageFrame[m] = 16;
13139 }
13140 }
13141 else
13142 {
13143 duckCageFrame[m] = 13;
13144 }
13145 }
13147 }
13148 else if (duckCageFrame[m] >= 13 && duckCageFrame[m] <= 15)
13149 {
13151 if (duckCageFrameCounter[m] < 5)
13152 {
13153 continue;
13154 }
13155 duckCageFrame[m]++;
13156 if (duckCageFrame[m] > 15)
13157 {
13158 if (rand.Next(5) != 0)
13159 {
13160 duckCageFrame[m] = 12;
13161 }
13162 else
13163 {
13164 duckCageFrame[m] = 13;
13165 }
13166 }
13168 }
13169 else if (duckCageFrame[m] >= 17)
13170 {
13172 if (duckCageFrameCounter[m] >= 5)
13173 {
13175 duckCageFrame[m]++;
13176 }
13177 if (duckCageFrame[m] > 23)
13178 {
13179 duckCageFrame[m] = 0;
13180 }
13181 }
13182 }
13183 for (int n = 0; n < cageFrames; n++)
13184 {
13186 bool flag = grebeCageFrame[n] == 0 || grebeCageFrame[n] == 7;
13187 bool num2 = grebeCageFrame[n] == 16 || grebeCageFrame[n] == 20;
13188 int num3 = 5;
13189 if (flag)
13190 {
13191 num3 = rand.Next(300, 400);
13192 }
13193 if (num2)
13194 {
13195 num3 = rand.Next(480, 600);
13196 }
13198 {
13199 continue;
13200 }
13202 if (grebeCageFrame[n] >= 25 && grebeCageFrame[n] <= 27)
13203 {
13204 grebeCageFrame[n]++;
13205 if (grebeCageFrame[n] > 27)
13206 {
13207 if (rand.Next(5) == 0)
13208 {
13209 grebeCageFrame[n] = 7;
13210 }
13211 else
13212 {
13213 grebeCageFrame[n] = 25;
13214 }
13215 }
13216 }
13217 else if (grebeCageFrame[n] >= 22 && grebeCageFrame[n] <= 24)
13218 {
13219 grebeCageFrame[n]++;
13220 if (grebeCageFrame[n] > 24)
13221 {
13222 if (rand.Next(5) == 0)
13223 {
13224 grebeCageFrame[n] = 0;
13225 }
13226 else
13227 {
13228 grebeCageFrame[n] = 22;
13229 }
13230 }
13231 }
13232 else if (grebeCageFrame[n] == 0 && rand.Next(3) == 0)
13233 {
13234 grebeCageFrame[n] = ((rand.Next(2) == 0) ? 22 : 14);
13235 }
13236 else if (grebeCageFrame[n] == 7 && rand.Next(3) == 0)
13237 {
13238 grebeCageFrame[n] = ((rand.Next(2) == 0) ? 25 : 18);
13239 }
13240 else if (grebeCageFrame[n] == 13 || grebeCageFrame[n] == 17)
13241 {
13242 grebeCageFrame[n] = 0;
13243 }
13244 else if (grebeCageFrame[n] == 21)
13245 {
13246 grebeCageFrame[n] = 7;
13247 }
13248 else
13249 {
13250 grebeCageFrame[n]++;
13251 }
13252 }
13253 for (int num4 = 0; num4 < cageFrames; num4++)
13254 {
13256 bool flag2 = seagullCageFrame[num4] == 0 || seagullCageFrame[num4] == 14;
13257 bool flag3 = seagullCageFrame[num4] >= 15 && seagullCageFrame[num4] <= 18;
13258 bool num5 = seagullCageFrame[num4] >= 9 && seagullCageFrame[num4] <= 13;
13259 int num6 = 6;
13260 if (flag2)
13261 {
13262 num6 = rand.Next(180, 250);
13263 }
13264 if (flag3)
13265 {
13266 num6 = 66;
13267 }
13268 if (num5)
13269 {
13270 num6 = 78;
13271 }
13273 {
13275 if (seagullCageFrame[num4] == 0 && rand.Next(3) == 0)
13276 {
13278 continue;
13279 }
13280 if (seagullCageFrame[num4] == 14)
13281 {
13282 if (rand.Next(2) == 0)
13283 {
13284 seagullCageFrame[num4] = 15;
13285 }
13286 else
13287 {
13288 seagullCageFrame[num4] = 19;
13289 }
13290 continue;
13291 }
13292 if (seagullCageFrame[num4] == 9)
13293 {
13295 continue;
13296 }
13297 if (seagullCageFrame[num4] == 8 || seagullCageFrame[num4] == 15)
13298 {
13299 seagullCageFrame[num4] = 14;
13300 continue;
13301 }
13303 if (seagullCageFrame[num4] > 26)
13304 {
13306 }
13307 }
13308 else if (seagullCageFrame[num4] >= 15 && seagullCageFrame[num4] <= 18)
13309 {
13310 int num7 = seagullCageFrameCounter[num4] % 66;
13311 if (num7 > 60)
13312 {
13313 seagullCageFrame[num4] = 15;
13314 }
13315 else if (num7 > 54)
13316 {
13317 seagullCageFrame[num4] = 16;
13318 }
13319 else if (num7 > 48)
13320 {
13321 seagullCageFrame[num4] = 17;
13322 }
13323 else if (num7 > 42)
13324 {
13325 seagullCageFrame[num4] = 18;
13326 }
13327 else if (num7 > 36)
13328 {
13329 seagullCageFrame[num4] = 17;
13330 }
13331 else if (num7 > 30)
13332 {
13333 seagullCageFrame[num4] = 16;
13334 }
13335 else if (num7 > 24)
13336 {
13337 seagullCageFrame[num4] = 17;
13338 }
13339 else if (num7 > 18)
13340 {
13341 seagullCageFrame[num4] = 18;
13342 }
13343 else if (num7 > 12)
13344 {
13345 seagullCageFrame[num4] = 17;
13346 }
13347 else if (num7 > 6)
13348 {
13349 seagullCageFrame[num4] = 16;
13350 }
13351 else
13352 {
13353 seagullCageFrame[num4] = 15;
13354 }
13355 }
13356 else if (seagullCageFrame[num4] >= 9 && seagullCageFrame[num4] <= 13)
13357 {
13358 int num8 = seagullCageFrameCounter[num4] % 78;
13359 if (num8 > 72)
13360 {
13362 }
13363 else if (num8 > 66)
13364 {
13365 seagullCageFrame[num4] = 10;
13366 }
13367 else if (num8 > 60)
13368 {
13369 seagullCageFrame[num4] = 11;
13370 }
13371 else if (num8 > 54)
13372 {
13373 seagullCageFrame[num4] = 12;
13374 }
13375 else if (num8 > 48)
13376 {
13377 seagullCageFrame[num4] = 13;
13378 }
13379 else if (num8 > 42)
13380 {
13381 seagullCageFrame[num4] = 12;
13382 }
13383 else if (num8 > 36)
13384 {
13385 seagullCageFrame[num4] = 11;
13386 }
13387 else if (num8 > 30)
13388 {
13389 seagullCageFrame[num4] = 12;
13390 }
13391 else if (num8 > 24)
13392 {
13393 seagullCageFrame[num4] = 13;
13394 }
13395 else if (num8 > 18)
13396 {
13397 seagullCageFrame[num4] = 12;
13398 }
13399 else if (num8 > 12)
13400 {
13401 seagullCageFrame[num4] = 11;
13402 }
13403 else if (num8 > 6)
13404 {
13405 seagullCageFrame[num4] = 10;
13406 }
13407 else
13408 {
13410 }
13411 }
13412 }
13413 for (int num9 = 0; num9 < cageFrames; num9++)
13414 {
13415 if (birdCageFrame[num9] == 0)
13416 {
13418 if (birdCageFrameCounter[num9] <= rand.Next(30, 2700))
13419 {
13420 continue;
13421 }
13422 if (rand.Next(3) != 0)
13423 {
13424 if (rand.Next(3) != 0)
13425 {
13426 birdCageFrame[num9] = 2;
13427 }
13428 else
13429 {
13430 birdCageFrame[num9] = 1;
13431 }
13432 }
13434 }
13435 else if (birdCageFrame[num9] == 1)
13436 {
13438 if (birdCageFrameCounter[num9] > rand.Next(900, 18000) && rand.Next(3) == 0)
13439 {
13441 birdCageFrame[num9] = 0;
13442 }
13443 }
13444 else if (birdCageFrame[num9] >= 2 && birdCageFrame[num9] <= 5)
13445 {
13447 if (birdCageFrameCounter[num9] >= 5)
13448 {
13450 if (birdCageFrame[num9] == 3 && rand.Next(3) == 0)
13451 {
13452 birdCageFrame[num9] = 13;
13453 }
13454 else
13455 {
13457 }
13458 }
13459 }
13460 else if (birdCageFrame[num9] == 6)
13461 {
13463 if (birdCageFrameCounter[num9] <= rand.Next(45, 2700))
13464 {
13465 continue;
13466 }
13467 if (rand.Next(3) != 0)
13468 {
13469 if (rand.Next(6) == 0)
13470 {
13471 birdCageFrame[num9] = 7;
13472 }
13473 else if (rand.Next(6) == 0)
13474 {
13475 birdCageFrame[num9] = 11;
13476 }
13477 }
13479 }
13480 else if (birdCageFrame[num9] >= 7 && birdCageFrame[num9] <= 10)
13481 {
13483 if (birdCageFrameCounter[num9] >= 5)
13484 {
13486 if (birdCageFrame[num9] > 10)
13487 {
13488 birdCageFrame[num9] = 0;
13489 }
13491 }
13492 }
13493 else if (birdCageFrame[num9] >= 11 && birdCageFrame[num9] <= 13)
13494 {
13496 if (birdCageFrameCounter[num9] >= 5)
13497 {
13500 }
13501 }
13502 else if (birdCageFrame[num9] == 14)
13503 {
13505 if (birdCageFrameCounter[num9] > rand.Next(5, 600))
13506 {
13507 if (rand.Next(20) == 0)
13508 {
13509 birdCageFrame[num9] = 16;
13510 }
13511 else if (rand.Next(20) == 0)
13512 {
13513 birdCageFrame[num9] = 4;
13514 }
13515 else
13516 {
13517 birdCageFrame[num9] = 15;
13518 }
13520 }
13521 }
13522 else if (birdCageFrame[num9] == 15)
13523 {
13525 if (birdCageFrameCounter[num9] >= 10)
13526 {
13528 birdCageFrame[num9] = 14;
13529 }
13530 }
13531 else
13532 {
13533 if (birdCageFrame[num9] < 16 || birdCageFrame[num9] > 18)
13534 {
13535 continue;
13536 }
13538 if (birdCageFrameCounter[num9] >= 5)
13539 {
13541 if (birdCageFrame[num9] > 18)
13542 {
13543 birdCageFrame[num9] = 0;
13544 }
13546 }
13547 }
13548 }
13549 for (int num10 = 0; num10 < cageFrames; num10++)
13550 {
13551 if (blueBirdCageFrame[num10] == 0)
13552 {
13554 if (blueBirdCageFrameCounter[num10] <= rand.Next(30, 2700))
13555 {
13556 continue;
13557 }
13558 if (rand.Next(3) != 0)
13559 {
13560 if (rand.Next(3) != 0)
13561 {
13563 }
13564 else
13565 {
13567 }
13568 }
13570 }
13571 else if (blueBirdCageFrame[num10] == 1)
13572 {
13574 if (blueBirdCageFrameCounter[num10] > rand.Next(900, 18000) && rand.Next(3) == 0)
13575 {
13578 }
13579 }
13580 else if (blueBirdCageFrame[num10] >= 2 && blueBirdCageFrame[num10] <= 5)
13581 {
13584 {
13586 if (blueBirdCageFrame[num10] == 3 && rand.Next(3) == 0)
13587 {
13589 }
13590 else
13591 {
13593 }
13594 }
13595 }
13596 else if (blueBirdCageFrame[num10] == 6)
13597 {
13599 if (blueBirdCageFrameCounter[num10] <= rand.Next(45, 2700))
13600 {
13601 continue;
13602 }
13603 if (rand.Next(3) != 0)
13604 {
13605 if (rand.Next(6) == 0)
13606 {
13608 }
13609 else if (rand.Next(6) == 0)
13610 {
13612 }
13613 }
13615 }
13616 else if (blueBirdCageFrame[num10] >= 7 && blueBirdCageFrame[num10] <= 10)
13617 {
13620 {
13622 if (blueBirdCageFrame[num10] > 10)
13623 {
13625 }
13627 }
13628 }
13629 else if (blueBirdCageFrame[num10] >= 11 && blueBirdCageFrame[num10] <= 13)
13630 {
13633 {
13636 }
13637 }
13638 else if (blueBirdCageFrame[num10] == 14)
13639 {
13641 if (blueBirdCageFrameCounter[num10] > rand.Next(5, 600))
13642 {
13643 if (rand.Next(20) == 0)
13644 {
13646 }
13647 else if (rand.Next(20) == 0)
13648 {
13650 }
13651 else
13652 {
13654 }
13656 }
13657 }
13658 else if (blueBirdCageFrame[num10] == 15)
13659 {
13662 {
13665 }
13666 }
13667 else
13668 {
13670 {
13671 continue;
13672 }
13675 {
13677 if (blueBirdCageFrame[num10] > 18)
13678 {
13680 }
13682 }
13683 }
13684 }
13685 for (int num11 = 0; num11 < cageFrames; num11++)
13686 {
13687 if (redBirdCageFrame[num11] == 0)
13688 {
13690 if (redBirdCageFrameCounter[num11] <= rand.Next(30, 2700))
13691 {
13692 continue;
13693 }
13694 if (rand.Next(3) != 0)
13695 {
13696 if (rand.Next(3) != 0)
13697 {
13699 }
13700 else
13701 {
13703 }
13704 }
13706 }
13707 else if (redBirdCageFrame[num11] == 1)
13708 {
13710 if (redBirdCageFrameCounter[num11] > rand.Next(900, 18000) && rand.Next(3) == 0)
13711 {
13714 }
13715 }
13716 else if (redBirdCageFrame[num11] >= 2 && redBirdCageFrame[num11] <= 5)
13717 {
13720 {
13722 if (redBirdCageFrame[num11] == 3 && rand.Next(3) == 0)
13723 {
13724 redBirdCageFrame[num11] = 13;
13725 }
13726 else
13727 {
13729 }
13730 }
13731 }
13732 else if (redBirdCageFrame[num11] == 6)
13733 {
13735 if (redBirdCageFrameCounter[num11] <= rand.Next(45, 2700))
13736 {
13737 continue;
13738 }
13739 if (rand.Next(3) != 0)
13740 {
13741 if (rand.Next(6) == 0)
13742 {
13744 }
13745 else if (rand.Next(6) == 0)
13746 {
13747 redBirdCageFrame[num11] = 11;
13748 }
13749 }
13751 }
13752 else if (redBirdCageFrame[num11] >= 7 && redBirdCageFrame[num11] <= 10)
13753 {
13756 {
13758 if (redBirdCageFrame[num11] > 10)
13759 {
13761 }
13763 }
13764 }
13765 else if (redBirdCageFrame[num11] >= 11 && redBirdCageFrame[num11] <= 13)
13766 {
13769 {
13772 }
13773 }
13774 else if (redBirdCageFrame[num11] == 14)
13775 {
13777 if (redBirdCageFrameCounter[num11] > rand.Next(5, 600))
13778 {
13779 if (rand.Next(20) == 0)
13780 {
13781 redBirdCageFrame[num11] = 16;
13782 }
13783 else if (rand.Next(20) == 0)
13784 {
13786 }
13787 else
13788 {
13789 redBirdCageFrame[num11] = 15;
13790 }
13792 }
13793 }
13794 else if (redBirdCageFrame[num11] == 15)
13795 {
13797 if (redBirdCageFrameCounter[num11] >= 10)
13798 {
13800 redBirdCageFrame[num11] = 14;
13801 }
13802 }
13803 else
13804 {
13805 if (redBirdCageFrame[num11] < 16 || redBirdCageFrame[num11] > 18)
13806 {
13807 continue;
13808 }
13811 {
13813 if (redBirdCageFrame[num11] > 18)
13814 {
13816 }
13818 }
13819 }
13820 }
13821 for (int num12 = 0; num12 < cageFrames; num12++)
13822 {
13823 if (macawCageFrame[num12] == 0)
13824 {
13826 if (macawCageFrameCounter[num12] <= rand.Next(300, 2700))
13827 {
13828 continue;
13829 }
13830 if (rand.Next(3) != 0)
13831 {
13832 if (rand.Next(3) != 0)
13833 {
13834 macawCageFrame[num12] = 16;
13835 }
13836 else
13837 {
13838 macawCageFrame[num12] = 1;
13839 }
13840 }
13842 }
13843 else if (macawCageFrame[num12] >= 1 && macawCageFrame[num12] <= 5)
13844 {
13847 {
13850 if (macawCageFrame[num12] > 5)
13851 {
13852 macawCageFrame[num12] = 6;
13853 }
13854 }
13855 }
13856 else if (macawCageFrame[num12] >= 16 && macawCageFrame[num12] <= 19)
13857 {
13860 {
13863 if (macawCageFrame[num12] > 19)
13864 {
13865 macawCageFrame[num12] = ((rand.Next(3) != 0) ? 16 : 0);
13866 }
13867 }
13868 }
13869 else if (macawCageFrame[num12] == 6)
13870 {
13872 if (macawCageFrameCounter[num12] <= rand.Next(300, 2700))
13873 {
13874 continue;
13875 }
13876 if (rand.Next(3) != 0)
13877 {
13878 if (rand.Next(3) != 0)
13879 {
13880 macawCageFrame[num12] = 7;
13881 }
13882 else
13883 {
13884 macawCageFrame[num12] = 11;
13885 }
13886 }
13888 }
13889 else if (macawCageFrame[num12] >= 11 && macawCageFrame[num12] <= 15)
13890 {
13893 {
13896 if (macawCageFrame[num12] > 15)
13897 {
13898 macawCageFrame[num12] = 0;
13899 }
13900 }
13901 }
13902 else
13903 {
13904 if (macawCageFrame[num12] < 7 || macawCageFrame[num12] > 10)
13905 {
13906 continue;
13907 }
13910 {
13913 if (macawCageFrame[num12] > 10)
13914 {
13915 macawCageFrame[num12] = ((rand.Next(3) == 0) ? 6 : 7);
13916 }
13917 }
13918 }
13919 }
13920 for (int num13 = 0; num13 < 2; num13++)
13921 {
13922 for (int num14 = 0; num14 < cageFrames; num14++)
13923 {
13925 {
13927 if (scorpionCageFrameCounter[num13, num14] <= rand.Next(30, 3600))
13928 {
13929 continue;
13930 }
13931 if (scorpionCageFrame[num13, num14] == 7)
13932 {
13934 }
13935 else if (rand.Next(3) == 0)
13936 {
13937 if (rand.Next(7) == 0)
13938 {
13940 }
13941 else if (rand.Next(4) == 0)
13942 {
13944 }
13945 else if (rand.Next(3) == 0)
13946 {
13948 }
13949 else
13950 {
13952 }
13953 }
13955 }
13956 else if (scorpionCageFrame[num13, num14] >= 1 && scorpionCageFrame[num13, num14] <= 2)
13957 {
13960 {
13963 }
13964 }
13965 else if (scorpionCageFrame[num13, num14] >= 8 && scorpionCageFrame[num13, num14] <= 10)
13966 {
13969 {
13972 }
13973 }
13974 else if (scorpionCageFrame[num13, num14] == 11)
13975 {
13977 if (scorpionCageFrameCounter[num13, num14] > rand.Next(45, 5400))
13978 {
13979 if (rand.Next(6) == 0)
13980 {
13982 }
13984 }
13985 }
13986 else if (scorpionCageFrame[num13, num14] >= 12 && scorpionCageFrame[num13, num14] <= 13)
13987 {
13990 {
13993 if (scorpionCageFrame[num13, num14] > 13)
13994 {
13996 }
13997 }
13998 }
13999 else if (scorpionCageFrame[num13, num14] >= 14 && scorpionCageFrame[num13, num14] <= 15)
14000 {
14003 {
14006 if (scorpionCageFrame[num13, num14] > 15)
14007 {
14009 }
14010 if (rand.Next(5) == 0)
14011 {
14013 }
14014 }
14015 }
14016 else if (scorpionCageFrame[num13, num14] == 4 || scorpionCageFrame[num13, num14] == 3)
14017 {
14019 if (scorpionCageFrameCounter[num13, num14] <= rand.Next(30, 3600))
14020 {
14021 continue;
14022 }
14023 if (scorpionCageFrame[num13, num14] == 3)
14024 {
14026 }
14027 else if (rand.Next(3) == 0)
14028 {
14029 if (rand.Next(5) == 0)
14030 {
14032 }
14033 else if (rand.Next(3) == 0)
14034 {
14036 }
14037 else
14038 {
14040 }
14041 }
14043 }
14044 else if (scorpionCageFrame[num13, num14] >= 5 && scorpionCageFrame[num13, num14] <= 6)
14045 {
14048 {
14051 if (scorpionCageFrame[num13, num14] > 7)
14052 {
14054 }
14055 }
14056 }
14057 else
14058 {
14060 {
14061 continue;
14062 }
14065 {
14068 if (scorpionCageFrame[num13, num14] > 17)
14069 {
14071 }
14072 if (rand.Next(5) == 0)
14073 {
14075 }
14076 }
14077 }
14078 }
14079 }
14080 for (int num15 = 0; num15 < cageFrames; num15++)
14081 {
14082 if (penguinCageFrame[num15] == 0)
14083 {
14085 if (penguinCageFrameCounter[num15] <= rand.Next(30, 1800))
14086 {
14087 continue;
14088 }
14089 if (rand.Next(2) == 0)
14090 {
14091 if (rand.Next(10) == 0)
14092 {
14094 }
14095 else if (rand.Next(7) == 0)
14096 {
14097 penguinCageFrame[num15] = 15;
14098 }
14099 else if (rand.Next(3) == 0)
14100 {
14102 }
14103 else
14104 {
14106 }
14107 }
14109 }
14110 else if (penguinCageFrame[num15] == 1)
14111 {
14113 if (penguinCageFrameCounter[num15] >= 10)
14114 {
14117 }
14118 }
14119 else if (penguinCageFrame[num15] >= 2 && penguinCageFrame[num15] <= 3)
14120 {
14123 {
14124 continue;
14125 }
14128 if (penguinCageFrame[num15] > 3)
14129 {
14130 if (rand.Next(3) == 0)
14131 {
14133 }
14134 else
14135 {
14137 }
14138 }
14139 }
14140 else if (penguinCageFrame[num15] >= 4 && penguinCageFrame[num15] <= 6)
14141 {
14143 if (penguinCageFrameCounter[num15] >= 10)
14144 {
14147 }
14148 }
14149 else if (penguinCageFrame[num15] == 15)
14150 {
14152 if (penguinCageFrameCounter[num15] > rand.Next(10, 1800))
14153 {
14154 if (rand.Next(2) == 0)
14155 {
14157 }
14159 }
14160 }
14161 else if (penguinCageFrame[num15] == 8)
14162 {
14164 if (penguinCageFrameCounter[num15] <= rand.Next(30, 3600))
14165 {
14166 continue;
14167 }
14168 if (rand.Next(2) == 0)
14169 {
14170 if (rand.Next(10) == 0)
14171 {
14172 penguinCageFrame[num15] = 12;
14173 }
14174 else if (rand.Next(7) == 0)
14175 {
14177 }
14178 else if (rand.Next(3) == 0)
14179 {
14180 penguinCageFrame[num15] = 10;
14181 }
14182 else
14183 {
14185 }
14186 }
14188 }
14189 else if (penguinCageFrame[num15] == 9)
14190 {
14192 if (penguinCageFrameCounter[num15] >= 10)
14193 {
14196 }
14197 }
14198 else if (penguinCageFrame[num15] >= 10 && penguinCageFrame[num15] <= 11)
14199 {
14202 {
14203 continue;
14204 }
14207 if (penguinCageFrame[num15] > 3)
14208 {
14209 if (rand.Next(3) == 0)
14210 {
14212 }
14213 else
14214 {
14215 penguinCageFrame[num15] = 10;
14216 }
14217 }
14218 }
14219 else if (penguinCageFrame[num15] >= 12 && penguinCageFrame[num15] <= 14)
14220 {
14222 if (penguinCageFrameCounter[num15] >= 10)
14223 {
14226 }
14227 }
14228 else
14229 {
14230 if (penguinCageFrame[num15] != 7)
14231 {
14232 continue;
14233 }
14235 if (penguinCageFrameCounter[num15] > rand.Next(10, 3600))
14236 {
14237 if (rand.Next(2) == 0)
14238 {
14240 }
14242 }
14243 }
14244 }
14245 for (int num16 = 0; num16 < cageFrames; num16++)
14246 {
14248 bool num17 = turtleCageFrame[num16] == 0 || turtleCageFrame[num16] == 15 || turtleCageFrame[num16] == 31;
14249 int num18 = 8;
14250 if (num17)
14251 {
14252 num18 = rand.Next(180, 250);
14253 }
14255 {
14256 continue;
14257 }
14259 if (turtleCageFrame[num16] == 29)
14260 {
14262 continue;
14263 }
14264 if (turtleCageFrame[num16] == 15 && rand.Next(3) == 0)
14265 {
14266 turtleCageFrame[num16] = 30;
14267 continue;
14268 }
14270 if (turtleCageFrame[num16] > 32)
14271 {
14272 turtleCageFrame[num16] = 15;
14273 }
14274 }
14275 for (int num19 = 0; num19 < cageFrames; num19++)
14276 {
14278 bool flag4 = seahorseCageFrame[num19] == 0 || seahorseCageFrame[num19] == 13;
14280 bool flag5 = seahorseCageFrame[num19] >= 25;
14281 int num21 = 7;
14282 if (flag4)
14283 {
14284 num21 = rand.Next(220, 340);
14285 }
14286 if (num20)
14287 {
14288 num21 = 10;
14289 }
14290 if (flag5)
14291 {
14292 num21 = 6;
14293 }
14295 {
14296 continue;
14297 }
14299 if (seahorseCageFrame[num19] == 0 && rand.Next(2) == 0)
14300 {
14302 continue;
14303 }
14304 if (seahorseCageFrame[num19] == 24)
14305 {
14307 continue;
14308 }
14310 if (seahorseCageFrame[num19] > 33)
14311 {
14313 }
14314 }
14316 for (int num22 = 0; num22 < cageFrames; num22++)
14317 {
14318 if (snailCageFrame[num22] >= 0 && snailCageFrame[num22] <= 13)
14319 {
14321 if (snailCageFrameCounter[num22] <= rand.Next(45, 3600))
14322 {
14323 continue;
14324 }
14325 if (snailCageFrame[num22] == 8 && rand.Next(2) == 0)
14326 {
14327 snailCageFrame[num22] = 14;
14328 }
14329 else if (snailCageFrame[num22] == 1 && rand.Next(3) == 0)
14330 {
14331 snailCageFrame[num22] = 19;
14332 }
14333 else if (snailCageFrame[num22] == 1 && rand.Next(3) == 0)
14334 {
14335 snailCageFrame[num22] = 20;
14336 }
14337 else
14338 {
14340 if (snailCageFrame[num22] > 13)
14341 {
14342 snailCageFrame[num22] = 0;
14343 }
14344 }
14346 }
14347 else if (snailCageFrame[num22] >= 14 && snailCageFrame[num22] <= 18)
14348 {
14350 if (snailCageFrameCounter[num22] >= 5)
14351 {
14354 }
14355 if (snailCageFrame[num22] > 18)
14356 {
14357 snailCageFrame[num22] = 20;
14358 }
14359 }
14360 else
14361 {
14362 if (snailCageFrame[num22] != 19 && snailCageFrame[num22] != 20)
14363 {
14364 continue;
14365 }
14367 if (snailCageFrameCounter[num22] <= rand.Next(60, 7200))
14368 {
14369 continue;
14370 }
14372 if (rand.Next(4) == 0)
14373 {
14374 if (rand.Next(3) == 0)
14375 {
14376 snailCageFrame[num22] = 2;
14377 }
14378 else if (snailCageFrame[num22] == 19)
14379 {
14380 snailCageFrame[num22] = 20;
14381 }
14382 else
14383 {
14384 snailCageFrame[num22] = 19;
14385 }
14386 }
14387 }
14388 }
14389 for (int num23 = 0; num23 < cageFrames; num23++)
14390 {
14391 if (snail2CageFrame[num23] >= 0 && snail2CageFrame[num23] <= 13)
14392 {
14394 if (snail2CageFrameCounter[num23] <= rand.Next(30, 2700))
14395 {
14396 continue;
14397 }
14398 if (snail2CageFrame[num23] == 8 && rand.Next(2) == 0)
14399 {
14400 snail2CageFrame[num23] = 14;
14401 }
14402 else if (snail2CageFrame[num23] == 1 && rand.Next(3) == 0)
14403 {
14404 snail2CageFrame[num23] = 19;
14405 }
14406 else if (snail2CageFrame[num23] == 1 && rand.Next(3) == 0)
14407 {
14408 snail2CageFrame[num23] = 20;
14409 }
14410 else
14411 {
14413 if (snail2CageFrame[num23] > 13)
14414 {
14416 }
14417 }
14419 }
14420 else if (snail2CageFrame[num23] >= 14 && snail2CageFrame[num23] <= 18)
14421 {
14423 if (snail2CageFrameCounter[num23] >= 5)
14424 {
14427 }
14428 if (snail2CageFrame[num23] > 18)
14429 {
14430 snail2CageFrame[num23] = 20;
14431 }
14432 }
14433 else
14434 {
14435 if (snail2CageFrame[num23] != 19 && snail2CageFrame[num23] != 20)
14436 {
14437 continue;
14438 }
14440 if (snail2CageFrameCounter[num23] <= rand.Next(45, 5400))
14441 {
14442 continue;
14443 }
14445 if (rand.Next(4) == 0)
14446 {
14447 if (rand.Next(3) == 0)
14448 {
14450 }
14451 else if (snail2CageFrame[num23] == 19)
14452 {
14453 snail2CageFrame[num23] = 20;
14454 }
14455 else
14456 {
14457 snail2CageFrame[num23] = 19;
14458 }
14459 }
14460 }
14461 }
14462 for (int num24 = 0; num24 < cageFrames; num24++)
14463 {
14464 if (frogCageFrame[num24] == 0)
14465 {
14467 if (frogCageFrameCounter[num24] > rand.Next(45, 3600))
14468 {
14469 if (rand.Next(10) == 0)
14470 {
14471 frogCageFrame[num24] = 1;
14472 }
14473 else
14474 {
14475 frogCageFrame[num24] = 12;
14476 }
14478 }
14479 }
14480 else if (frogCageFrame[num24] >= 1 && frogCageFrame[num24] <= 5)
14481 {
14483 if (frogCageFrameCounter[num24] >= 5)
14484 {
14487 }
14488 }
14489 else if (frogCageFrame[num24] >= 12 && frogCageFrame[num24] <= 17)
14490 {
14492 if (frogCageFrameCounter[num24] >= 5)
14493 {
14496 }
14497 if (frogCageFrame[num24] > 17)
14498 {
14499 if (rand.Next(3) == 0)
14500 {
14501 frogCageFrame[num24] = 0;
14502 }
14503 else
14504 {
14505 frogCageFrame[num24] = 12;
14506 }
14507 }
14508 }
14509 else if (frogCageFrame[num24] == 6)
14510 {
14512 if (frogCageFrameCounter[num24] > rand.Next(45, 3600))
14513 {
14514 if (rand.Next(10) == 0)
14515 {
14516 frogCageFrame[num24] = 7;
14517 }
14518 else
14519 {
14520 frogCageFrame[num24] = 18;
14521 }
14523 }
14524 }
14525 else if (frogCageFrame[num24] >= 7 && frogCageFrame[num24] <= 11)
14526 {
14528 if (frogCageFrameCounter[num24] >= 5)
14529 {
14532 if (frogCageFrame[num24] > 11)
14533 {
14534 frogCageFrame[num24] = 0;
14535 }
14536 }
14537 }
14538 else
14539 {
14540 if (frogCageFrame[num24] < 18 || frogCageFrame[num24] > 23)
14541 {
14542 continue;
14543 }
14545 if (frogCageFrameCounter[num24] >= 5)
14546 {
14549 }
14550 if (frogCageFrame[num24] > 17)
14551 {
14552 if (rand.Next(3) == 0)
14553 {
14554 frogCageFrame[num24] = 6;
14555 }
14556 else
14557 {
14558 frogCageFrame[num24] = 18;
14559 }
14560 }
14561 }
14562 }
14563 for (int num25 = 0; num25 < cageFrames; num25++)
14564 {
14565 if (mouseCageFrame[num25] >= 0 && mouseCageFrame[num25] <= 1)
14566 {
14568 if (mouseCageFrameCounter[num25] >= 5)
14569 {
14571 if (mouseCageFrame[num25] > 1)
14572 {
14573 mouseCageFrame[num25] = 0;
14574 }
14576 if (rand.Next(15) == 0)
14577 {
14578 mouseCageFrame[num25] = 4;
14579 }
14580 }
14581 }
14582 else if (mouseCageFrame[num25] >= 4 && mouseCageFrame[num25] <= 7)
14583 {
14585 if (mouseCageFrameCounter[num25] >= 5)
14586 {
14589 }
14590 if (mouseCageFrame[num25] > 7)
14591 {
14592 mouseCageFrame[num25] = 2;
14593 }
14594 }
14595 else if (mouseCageFrame[num25] >= 2 && mouseCageFrame[num25] <= 3)
14596 {
14598 if (mouseCageFrameCounter[num25] >= 5)
14599 {
14601 if (mouseCageFrame[num25] > 3)
14602 {
14603 mouseCageFrame[num25] = 2;
14604 }
14606 if (rand.Next(15) == 0)
14607 {
14608 mouseCageFrame[num25] = 8;
14609 }
14610 else if (rand.Next(15) == 0)
14611 {
14612 mouseCageFrame[num25] = 12;
14613 }
14614 }
14615 }
14616 else if (mouseCageFrame[num25] >= 8 && mouseCageFrame[num25] <= 11)
14617 {
14619 if (mouseCageFrameCounter[num25] >= 5)
14620 {
14623 }
14624 if (mouseCageFrame[num25] > 11)
14625 {
14626 mouseCageFrame[num25] = 0;
14627 }
14628 }
14629 else if (mouseCageFrame[num25] >= 12 && mouseCageFrame[num25] <= 13)
14630 {
14632 if (mouseCageFrameCounter[num25] >= 5)
14633 {
14636 }
14637 }
14638 else if (mouseCageFrame[num25] >= 14 && mouseCageFrame[num25] <= 17)
14639 {
14641 if (mouseCageFrameCounter[num25] >= 5)
14642 {
14645 if (mouseCageFrame[num25] > 17 && rand.Next(20) != 0)
14646 {
14647 mouseCageFrame[num25] = 14;
14648 }
14649 }
14650 }
14651 else
14652 {
14653 if (mouseCageFrame[num25] < 18 || mouseCageFrame[num25] > 19)
14654 {
14655 continue;
14656 }
14658 if (mouseCageFrameCounter[num25] >= 5)
14659 {
14662 if (mouseCageFrame[num25] > 19)
14663 {
14664 mouseCageFrame[num25] = 0;
14665 }
14666 }
14667 }
14668 }
14669 for (int num26 = 0; num26 < cageFrames; num26++)
14670 {
14672 if (wormCageFrameCounter[num26] < rand.Next(30, 91))
14673 {
14674 continue;
14675 }
14677 if (rand.Next(4) != 0)
14678 {
14679 continue;
14680 }
14682 if (wormCageFrame[num26] == 9 && rand.Next(2) == 0)
14683 {
14684 wormCageFrame[num26] = 0;
14685 }
14686 if (wormCageFrame[num26] > 18)
14687 {
14688 if (rand.Next(2) == 0)
14689 {
14690 wormCageFrame[num26] = 9;
14691 }
14692 else
14693 {
14694 wormCageFrame[num26] = 0;
14695 }
14696 }
14697 }
14698 int num27 = 0;
14699 for (int num28 = 0; num28 < 3; num28++)
14700 {
14701 switch (num28)
14702 {
14703 case 0:
14704 num27 = 24;
14705 break;
14706 case 1:
14707 num27 = 31;
14708 break;
14709 case 2:
14710 num27 = 34;
14711 break;
14712 }
14713 for (int num29 = 0; num29 < cageFrames; num29++)
14714 {
14715 if (++slugCageFrameCounter[num28, num29] >= rand.Next(5, 15))
14716 {
14718 if (++slugCageFrame[num28, num29] >= num27)
14719 {
14721 }
14722 }
14723 }
14724 }
14725 for (int num30 = 0; num30 < cageFrames; num30++)
14726 {
14728 {
14731 {
14733 if (grasshopperCageFrame[num30] > 1)
14734 {
14736 }
14738 if (rand.Next(15) == 0)
14739 {
14741 }
14742 }
14743 }
14744 else if (grasshopperCageFrame[num30] >= 2 && grasshopperCageFrame[num30] <= 5)
14745 {
14748 {
14751 }
14752 if (grasshopperCageFrame[num30] > 5)
14753 {
14755 }
14756 }
14757 else if (grasshopperCageFrame[num30] >= 6 && grasshopperCageFrame[num30] <= 7)
14758 {
14761 {
14763 if (grasshopperCageFrame[num30] > 7)
14764 {
14766 }
14768 if (rand.Next(15) == 0)
14769 {
14771 }
14772 }
14773 }
14774 else if (grasshopperCageFrame[num30] >= 8 && grasshopperCageFrame[num30] <= 11)
14775 {
14778 {
14781 }
14782 if (grasshopperCageFrame[num30] > 11)
14783 {
14785 }
14786 }
14787 }
14788 for (int num31 = 0; num31 < cageFrames; num31++)
14789 {
14791 bool num32 = maggotCageFrame[num31] == 0 || maggotCageFrame[num31] == 6 || maggotCageFrame[num31] == 18;
14792 int num33 = 8;
14793 if (num32)
14794 {
14795 num33 = rand.Next(100, 140);
14796 }
14798 {
14799 continue;
14800 }
14802 if (maggotCageFrame[num31] == 0)
14803 {
14804 if (rand.Next(3) == 0)
14805 {
14806 maggotCageFrame[num31] = 13;
14807 }
14808 else
14809 {
14811 }
14812 continue;
14813 }
14814 if (maggotCageFrame[num31] == 12)
14815 {
14817 continue;
14818 }
14820 if (maggotCageFrame[num31] > 23)
14821 {
14823 }
14824 }
14825 for (int num34 = 0; num34 < cageFrames; num34++)
14826 {
14829 int num35 = rand.Next(10, 12);
14830 if (ladybugCageFrame[num34] == 18)
14831 {
14832 num35 = rand.Next(160, 241);
14833 }
14834 else if (flag6)
14835 {
14836 num35 = rand.Next(198, 206);
14837 }
14838 else if (ladybugCageFrame[num34] >= 8 && ladybugCageFrame[num34] <= 16)
14839 {
14840 num35 = 5;
14841 }
14843 {
14844 continue;
14845 }
14847 if (ladybugCageFrame[num34] < 18)
14848 {
14849 if ((ladybugCageFrame[num34] == 2 || ladybugCageFrame[num34] == 5) && rand.Next(3) == 0)
14850 {
14851 ladybugCageFrame[num34] = 17;
14852 }
14853 else if (ladybugCageFrame[num34] == 3 || ladybugCageFrame[num34] == 12)
14854 {
14855 switch (rand.Next(3))
14856 {
14857 case 0:
14858 case 1:
14860 break;
14861 case 2:
14862 ladybugCageFrame[num34] = 13;
14863 break;
14864 }
14865 }
14866 else if (ladybugCageFrame[num34] == 7 || ladybugCageFrame[num34] == 16)
14867 {
14868 switch (rand.Next(3))
14869 {
14870 case 0:
14871 case 1:
14873 break;
14874 case 2:
14876 break;
14877 }
14878 }
14879 else
14880 {
14882 }
14883 }
14884 else
14885 {
14886 ladybugCageFrame[num34] = ((rand.Next(2) == 0) ? 13 : 4);
14887 }
14888 }
14889 for (int num36 = 0; num36 < cageFrames; num36++)
14890 {
14892 bool flag7 = ratCageFrame[num36] == 0 || ratCageFrame[num36] == 4;
14893 bool num37 = ratCageFrame[num36] == 8 || ratCageFrame[num36] == 9 || ratCageFrame[num36] == 10 || ratCageFrame[num36] == 11;
14894 bool flag8 = ratCageFrame[num36] > 11;
14895 int num38 = 5;
14896 if (flag7)
14897 {
14898 num38 = rand.Next(40, 70);
14899 }
14900 if (num37)
14901 {
14902 num38 = rand.Next(70, 110);
14903 }
14904 if (flag8)
14905 {
14906 num38 = 180;
14907 }
14909 {
14911 if (ratCageFrame[num36] == 0 && rand.Next(2) == 0)
14912 {
14913 if (rand.Next(3) != 0)
14914 {
14915 ratCageFrame[num36] = 12;
14916 }
14917 else
14918 {
14919 ratCageFrame[num36] = 8;
14920 }
14921 continue;
14922 }
14923 if (ratCageFrame[num36] == 4 && rand.Next(2) == 0)
14924 {
14925 ratCageFrame[num36] = 10;
14926 continue;
14927 }
14928 if (ratCageFrame[num36] == 7 || ratCageFrame[num36] == 9 || ratCageFrame[num36] == 12)
14929 {
14930 ratCageFrame[num36] = 0;
14931 continue;
14932 }
14933 if (ratCageFrame[num36] == 11)
14934 {
14935 ratCageFrame[num36] = 4;
14936 continue;
14937 }
14939 if (ratCageFrame[num36] > 16)
14940 {
14941 ratCageFrame[num36] = 0;
14942 }
14943 }
14944 else if (ratCageFrame[num36] > 11)
14945 {
14946 int num39 = ratCageFrameCounter[num36] % 90;
14947 if (num39 > 80)
14948 {
14949 ratCageFrame[num36] = 12;
14950 }
14951 else if (num39 > 70)
14952 {
14953 ratCageFrame[num36] = 13;
14954 }
14955 else if (num39 > 60)
14956 {
14957 ratCageFrame[num36] = 14;
14958 }
14959 else if (num39 > 50)
14960 {
14961 ratCageFrame[num36] = 15;
14962 }
14963 else if (num39 > 40)
14964 {
14965 ratCageFrame[num36] = 16;
14966 }
14967 else if (num39 > 30)
14968 {
14969 ratCageFrame[num36] = 15;
14970 }
14971 else if (num39 > 20)
14972 {
14973 ratCageFrame[num36] = 14;
14974 }
14975 else if (num39 > 10)
14976 {
14977 ratCageFrame[num36] = 13;
14978 }
14979 else
14980 {
14981 ratCageFrame[num36] = 12;
14982 }
14983 }
14984 else if (ratCageFrameCounter[num36] % 10 == 0)
14985 {
14986 if (ratCageFrame[num36] == 8 || ratCageFrame[num36] == 10)
14987 {
14989 }
14990 else if (ratCageFrame[num36] == 9 || ratCageFrame[num36] == 11)
14991 {
14993 }
14994 }
14995 }
14996 for (int num40 = 0; num40 < cageFrames; num40++)
14997 {
15001 int num42 = 5;
15002 if (flag9)
15003 {
15004 num42 = rand.Next(110, 210);
15005 }
15006 if (num41)
15007 {
15008 num42 = rand.Next(150, 260);
15009 }
15011 {
15012 continue;
15013 }
15015 if (waterStriderCageFrame[num40] == 0 && rand.Next(2) == 0)
15016 {
15018 continue;
15019 }
15020 if (waterStriderCageFrame[num40] == 8 && rand.Next(2) == 0)
15021 {
15023 continue;
15024 }
15026 {
15028 continue;
15029 }
15031 if (waterStriderCageFrame[num40] > 21)
15032 {
15034 }
15035 }
15037 if (fairyJarFrameCounter[0] > 5)
15038 {
15039 fairyJarFrameCounter[0] = 0;
15040 fairyJarFrame[0]++;
15041 if (fairyJarFrame[0] > 11)
15042 {
15043 fairyJarFrame[0] = 0;
15044 }
15045 }
15046 for (int num43 = 1; num43 < cageFrames; num43++)
15047 {
15048 int num44 = fairyJarFrame[0] + num43 % 12;
15049 if (num43 % 2 == 0)
15050 {
15051 num44++;
15052 }
15053 if (num43 % 5 == 0)
15054 {
15055 num44++;
15056 }
15057 if (num43 % 8 == 0)
15058 {
15059 num44++;
15060 }
15061 while (num44 >= 12)
15062 {
15063 num44 -= 12;
15064 }
15066 }
15067 for (int num45 = 0; num45 < cageFrames; num45++)
15068 {
15069 byte maxValue = 5;
15070 if (fishBowlFrameMode[num45] == 1)
15071 {
15072 if (rand.Next(900) == 0)
15073 {
15074 fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
15075 }
15077 if (fishBowlFrameCounter[num45] < 5)
15078 {
15079 continue;
15080 }
15082 if (fishBowlFrame[num45] == 10)
15083 {
15084 if (rand.Next(20) == 0)
15085 {
15086 fishBowlFrame[num45] = 11;
15088 }
15089 else
15090 {
15091 fishBowlFrame[num45] = 1;
15092 }
15093 }
15094 else
15095 {
15097 }
15098 }
15099 else if (fishBowlFrameMode[num45] == 2)
15100 {
15101 if (rand.Next(3600) == 0)
15102 {
15103 fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
15104 }
15106 if (fishBowlFrameCounter[num45] < 20)
15107 {
15108 continue;
15109 }
15111 if (fishBowlFrame[num45] == 10)
15112 {
15113 if (rand.Next(20) == 0)
15114 {
15115 fishBowlFrame[num45] = 11;
15117 }
15118 else
15119 {
15120 fishBowlFrame[num45] = 1;
15121 }
15122 }
15123 else
15124 {
15126 }
15127 }
15128 else if (fishBowlFrameMode[num45] == 3)
15129 {
15130 if (rand.Next(3600) == 0)
15131 {
15132 fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
15133 }
15135 if (fishBowlFrameCounter[num45] < rand.Next(5, 3600))
15136 {
15137 continue;
15138 }
15140 if (fishBowlFrame[num45] == 10)
15141 {
15142 if (rand.Next(20) == 0)
15143 {
15144 fishBowlFrame[num45] = 11;
15146 }
15147 else
15148 {
15149 fishBowlFrame[num45] = 1;
15150 }
15151 }
15152 else
15153 {
15155 }
15156 }
15157 else if (fishBowlFrame[num45] <= 10)
15158 {
15159 if (rand.Next(3600) == 0)
15160 {
15161 fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
15162 }
15164 if (fishBowlFrameCounter[num45] < 10)
15165 {
15166 continue;
15167 }
15169 if (fishBowlFrame[num45] == 10)
15170 {
15171 if (rand.Next(12) == 0)
15172 {
15173 fishBowlFrame[num45] = 11;
15174 }
15175 else
15176 {
15177 fishBowlFrame[num45] = 1;
15178 }
15179 }
15180 else
15181 {
15183 }
15184 }
15185 else if (fishBowlFrame[num45] == 12 || fishBowlFrame[num45] == 13)
15186 {
15188 if (fishBowlFrameCounter[num45] < 10)
15189 {
15190 continue;
15191 }
15194 if (fishBowlFrame[num45] > 13)
15195 {
15196 if (rand.Next(20) == 0)
15197 {
15198 fishBowlFrame[num45] = 14;
15199 }
15200 else
15201 {
15202 fishBowlFrame[num45] = 12;
15203 }
15204 }
15205 }
15206 else
15207 {
15208 if (fishBowlFrame[num45] < 11)
15209 {
15210 continue;
15211 }
15213 if (fishBowlFrameCounter[num45] >= 10)
15214 {
15217 if (fishBowlFrame[num45] > 16)
15218 {
15219 fishBowlFrame[num45] = 4;
15220 }
15221 }
15222 }
15223 }
15224 for (int num46 = 0; num46 < cageFrames; num46++)
15225 {
15227 if (lavaFishBowlFrameCounter[num46] > 4 + rand.Next(3))
15228 {
15231 if (lavaFishBowlFrame[num46] > 26)
15232 {
15234 }
15235 }
15236 }
15237 for (int num47 = 0; num47 < 9; num47++)
15238 {
15239 for (int num48 = 0; num48 < cageFrames; num48++)
15240 {
15242 if (rand.Next(3600) == 0)
15243 {
15244 butterflyCageMode[num47, num48] = (byte)rand.Next(5);
15245 if (rand.Next(2) == 0)
15246 {
15248 }
15249 }
15250 int num49 = rand.Next(3, 16);
15252 {
15253 num49 = 3;
15254 }
15256 {
15257 num49 = 5;
15258 }
15260 {
15261 num49 = 10;
15262 }
15264 {
15265 num49 = 15;
15266 }
15267 if (butterflyCageMode[num47, num48] >= 10)
15268 {
15269 if (butterflyCageFrame[num47, num48] <= 7)
15270 {
15272 {
15273 continue;
15274 }
15277 if (butterflyCageFrame[num47, num48] < 0)
15278 {
15280 }
15282 {
15283 continue;
15284 }
15285 if (rand.Next(20) == 0)
15286 {
15288 }
15289 else if (rand.Next(6) == 0)
15290 {
15291 if (butterflyCageMode[num47, num48] >= 10)
15292 {
15294 }
15295 else
15296 {
15298 }
15299 }
15300 }
15301 else
15302 {
15304 {
15305 continue;
15306 }
15309 if (butterflyCageFrame[num47, num48] < 8)
15310 {
15312 }
15314 {
15315 continue;
15316 }
15317 if (rand.Next(20) == 0)
15318 {
15320 }
15321 else if (rand.Next(6) == 0)
15322 {
15323 if (butterflyCageMode[num47, num48] >= 10)
15324 {
15326 }
15327 else
15328 {
15330 }
15331 }
15332 }
15333 }
15334 else if (butterflyCageFrame[num47, num48] <= 7)
15335 {
15337 {
15340 if (butterflyCageFrame[num47, num48] > 7)
15341 {
15343 }
15344 if ((butterflyCageFrame[num47, num48] == 1 || butterflyCageFrame[num47, num48] == 4 || butterflyCageFrame[num47, num48] == 6) && rand.Next(10) == 0)
15345 {
15347 }
15348 }
15349 }
15351 {
15354 if (butterflyCageFrame[num47, num48] > 15)
15355 {
15357 }
15358 if ((butterflyCageFrame[num47, num48] == 9 || butterflyCageFrame[num47, num48] == 12 || butterflyCageFrame[num47, num48] == 14) && rand.Next(10) == 0)
15359 {
15361 }
15362 }
15363 }
15364 }
15366 for (int num50 = 0; num50 < 3; num50++)
15367 {
15368 for (int num51 = 0; num51 < cageFrames; num51++)
15369 {
15371 if (jellyfishCageMode[num50, num51] == 0 && rand.Next(1800) == 0)
15372 {
15374 }
15375 if (jellyfishCageMode[num50, num51] == 2 && rand.Next(60) == 0)
15376 {
15378 }
15379 int num52 = 1;
15380 if (jellyfishCageMode[num50, num51] == 0)
15381 {
15382 num52 = rand.Next(10, 20);
15383 }
15384 if (jellyfishCageMode[num50, num51] == 1)
15385 {
15386 num52 = rand.Next(15, 25);
15387 }
15388 if (jellyfishCageMode[num50, num51] == 2)
15389 {
15390 num52 = rand.Next(4, 9);
15391 }
15392 if (jellyfishCageMode[num50, num51] == 3)
15393 {
15394 num52 = rand.Next(15, 25);
15395 }
15397 {
15400 if (jellyfishCageFrame[num50, num51] >= 4)
15401 {
15403 }
15404 }
15406 {
15409 if (jellyfishCageFrame[num50, num51] >= 7)
15410 {
15412 }
15413 }
15415 {
15418 if (jellyfishCageFrame[num50, num51] >= 9)
15419 {
15421 }
15422 }
15424 {
15427 if (jellyfishCageFrame[num50, num51] >= 10)
15428 {
15431 }
15432 }
15433 }
15434 }
15435 }
static int[] blueBirdCageFrameCounter
Definition Main.cs:1551
static int[,] butterflyCageFrameCounter
Definition Main.cs:1561
static int[] turtleCageFrame
Definition Main.cs:1597
static int[] bunnyCageFrameCounter
Definition Main.cs:1515
static int[] seahorseCageFrame
Definition Main.cs:1635
static byte[,] jellyfishCageMode
Definition Main.cs:1605
static bool critterCage
Definition Main.cs:1511
static int[] seagullCageFrame
Definition Main.cs:1537
static int[] ratCageFrameCounter
Definition Main.cs:1621
static int[] penguinCageFrame
Definition Main.cs:1627
static int[,] slugCageFrame
Definition Main.cs:1639
static void UpdateDragonflyJarFrames()
Definition Main.cs:15445
static int[] duckCageFrame
Definition Main.cs:1529
static int[] frogCageFrameCounter
Definition Main.cs:1591
static int[] birdCageFrameCounter
Definition Main.cs:1543
static int[,] scorpionCageFrame
Definition Main.cs:1567
static int[,] jellyfishCageFrameCounter
Definition Main.cs:1609
static int[] frogCageFrame
Definition Main.cs:1589
static int[] grasshopperCageFrameCounter
Definition Main.cs:1649
static int[] squirrelCageFrameCounterOrange
Definition Main.cs:1523
static int[] ladybugCageFrameCounter
Definition Main.cs:1625
static int[] ladybugCageFrame
Definition Main.cs:1623
static void UpdateOwlCageFrames()
Definition Main.cs:15437
static int[] lavaFishBowlFrameCounter
Definition Main.cs:1587
static int[] macawCageFrameCounter
Definition Main.cs:1555
static int[] waterStriderCageFrameCounter
Definition Main.cs:1633
static int[] squirrelCageFrame
Definition Main.cs:1517
static int[] snailCageFrame
Definition Main.cs:1571
static byte[] fishBowlFrameMode
Definition Main.cs:1579
static int[] squirrelCageFrameOrange
Definition Main.cs:1521
static int[] snailCageFrameCounter
Definition Main.cs:1573
static int[] grebeCageFrameCounter
Definition Main.cs:1535
static int[,] slugCageFrameCounter
Definition Main.cs:1641
static int[] redBirdCageFrame
Definition Main.cs:1545
static int[] fairyJarFrameCounter
Definition Main.cs:1603
static int[] redBirdCageFrameCounter
Definition Main.cs:1547
static int[] fishBowlFrame
Definition Main.cs:1581
static int[] macawCageFrame
Definition Main.cs:1553
static int[] maggotCageFrameCounter
Definition Main.cs:1617
static int[] seahorseCageFrameCounter
Definition Main.cs:1637
static int[] bunnyCageFrame
Definition Main.cs:1513
static int[] turtleCageFrameCounter
Definition Main.cs:1599
static int[] birdCageFrame
Definition Main.cs:1541
static int[] grasshopperCageFrame
Definition Main.cs:1647
static int[] mouseCageFrame
Definition Main.cs:1593
static int[] mouseCageFrameCounter
Definition Main.cs:1595
static int[] ratCageFrame
Definition Main.cs:1619
static int[] squirrelCageFrameCounter
Definition Main.cs:1519
static UnifiedRandom rand
Definition Main.cs:1387
static int[] wormCageFrameCounter
Definition Main.cs:1613
static int[] fishBowlFrameCounter
Definition Main.cs:1583
static int[] blueBirdCageFrame
Definition Main.cs:1549
static int[] maggotCageFrame
Definition Main.cs:1615
static int cageFrames
Definition Main.cs:1509
static int[] waterStriderCageFrame
Definition Main.cs:1631
static int[,] butterflyCageFrame
Definition Main.cs:1559
static int[] snail2CageFrame
Definition Main.cs:1575
static int[] duckCageFrameCounter
Definition Main.cs:1531
static int[] grebeCageFrame
Definition Main.cs:1533
static int[] penguinCageFrameCounter
Definition Main.cs:1629
static int[] mallardCageFrameCounter
Definition Main.cs:1527
static int[] snail2CageFrameCounter
Definition Main.cs:1577
static int[] wormCageFrame
Definition Main.cs:1611
static int[] fairyJarFrame
Definition Main.cs:1601
static int[] mallardCageFrame
Definition Main.cs:1525
static byte[,] butterflyCageMode
Definition Main.cs:1557
static int[,] jellyfishCageFrame
Definition Main.cs:1607
static int[] lavaFishBowlFrame
Definition Main.cs:1585
static int[] seagullCageFrameCounter
Definition Main.cs:1539
static int[,] scorpionCageFrameCounter
Definition Main.cs:1569

References Terraria.Main.birdCageFrame, Terraria.Main.birdCageFrameCounter, Terraria.Main.blueBirdCageFrame, Terraria.Main.blueBirdCageFrameCounter, Terraria.Main.bunnyCageFrame, Terraria.Main.bunnyCageFrameCounter, Terraria.Main.butterflyCageFrame, Terraria.Main.butterflyCageFrameCounter, Terraria.Main.butterflyCageMode, Terraria.Main.cageFrames, Terraria.Main.critterCage, Terraria.Main.duckCageFrame, Terraria.Main.duckCageFrameCounter, Terraria.Main.fairyJarFrame, Terraria.Main.fairyJarFrameCounter, Terraria.Main.fishBowlFrame, Terraria.Main.fishBowlFrameCounter, Terraria.Main.fishBowlFrameMode, Terraria.Main.frogCageFrame, Terraria.Main.frogCageFrameCounter, Terraria.Main.grasshopperCageFrame, Terraria.Main.grasshopperCageFrameCounter, Terraria.Main.grebeCageFrame, Terraria.Main.grebeCageFrameCounter, System.Text.RegularExpressions.i, Terraria.Main.jellyfishCageFrame, Terraria.Main.jellyfishCageFrameCounter, Terraria.Main.jellyfishCageMode, Terraria.Main.ladybugCageFrame, Terraria.Main.ladybugCageFrameCounter, Terraria.Main.lavaFishBowlFrame, Terraria.Main.lavaFishBowlFrameCounter, Terraria.Main.macawCageFrame, Terraria.Main.macawCageFrameCounter, Terraria.Main.maggotCageFrame, Terraria.Main.maggotCageFrameCounter, Terraria.Main.mallardCageFrame, Terraria.Main.mallardCageFrameCounter, Terraria.Main.mouseCageFrame, Terraria.Main.mouseCageFrameCounter, Terraria.Main.penguinCageFrame, Terraria.Main.penguinCageFrameCounter, Terraria.Main.rand, Terraria.Main.ratCageFrame, Terraria.Main.ratCageFrameCounter, Terraria.Main.redBirdCageFrame, Terraria.Main.redBirdCageFrameCounter, Terraria.Main.scorpionCageFrame, Terraria.Main.scorpionCageFrameCounter, Terraria.Main.seagullCageFrame, Terraria.Main.seagullCageFrameCounter, Terraria.Main.seahorseCageFrame, Terraria.Main.seahorseCageFrameCounter, Terraria.Main.slugCageFrame, Terraria.Main.slugCageFrameCounter, Terraria.Main.snail2CageFrame, Terraria.Main.snail2CageFrameCounter, Terraria.Main.snailCageFrame, Terraria.Main.snailCageFrameCounter, Terraria.Main.squirrelCageFrame, Terraria.Main.squirrelCageFrameCounter, Terraria.Main.squirrelCageFrameCounterOrange, Terraria.Main.squirrelCageFrameOrange, Terraria.Main.turtleCageFrame, Terraria.Main.turtleCageFrameCounter, Terraria.Main.UpdateDragonflyJarFrames(), Terraria.Main.UpdateOwlCageFrames(), Terraria.Main.waterStriderCageFrame, Terraria.Main.waterStriderCageFrameCounter, Terraria.Main.wormCageFrame, and Terraria.Main.wormCageFrameCounter.

Referenced by Terraria.Main.AnimateTiles(), and Terraria.Main.Initialize_TileAndNPCData2().