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

◆ GrowLivingTree()

static bool Terraria.WorldGen.GrowLivingTree ( int i,
int j,
bool patch = false )
inlinestatic

Definition at line 19604 of file WorldGen.cs.

19605 {
19606 //IL_0d1f: Unknown result type (might be due to invalid IL or missing references)
19607 //IL_0d2a: Unknown result type (might be due to invalid IL or missing references)
19608 //IL_0d2f: Unknown result type (might be due to invalid IL or missing references)
19609 //IL_0d34: Unknown result type (might be due to invalid IL or missing references)
19610 int num = 0;
19611 int[] array = new int[1000];
19612 int[] array2 = new int[1000];
19613 int[] array3 = new int[1000];
19614 int[] array4 = new int[1000];
19615 int num2 = 0;
19616 int[] array5 = new int[2000];
19617 int[] array6 = new int[2000];
19618 bool[] array7 = new bool[2000];
19619 if (!SolidTile(i, j + 1))
19620 {
19621 return false;
19622 }
19623 if (Main.tile[i, j].active())
19624 {
19625 return false;
19626 }
19627 if (Main.tile[i, j + 1].type != 0 && Main.tile[i, j + 1].type != 2 && Main.tile[i, j + 1].type != 1 && Main.tile[i, j + 1].type != 40 && !TileID.Sets.Ore[Main.tile[i, j + 1].type] && (!remixWorldGen || !notTheBees || (Main.tile[i, j + 1].type != 60 && Main.tile[i, j + 1].type != 59)))
19628 {
19629 return false;
19630 }
19631 if (j < 150)
19632 {
19633 return false;
19634 }
19635 int num3 = i - genRand.Next(2, 3);
19636 int num4 = i + genRand.Next(2, 3);
19637 if (genRand.Next(5) == 0)
19638 {
19639 if (genRand.Next(2) == 0)
19640 {
19641 num3--;
19642 }
19643 else
19644 {
19645 num4++;
19646 }
19647 }
19648 int num5 = num4 - num3;
19649 bool flag = num5 >= 4;
19650 int num6 = i - 50;
19651 int num7 = i + 50;
19652 if (patch)
19653 {
19654 num6 = i - 20;
19655 num7 = i + 20;
19656 num3 = i - genRand.Next(1, 3);
19657 num4 = i + genRand.Next(1, 3);
19658 flag = num5 >= 4;
19659 }
19660 for (int k = num6; k <= num7; k++)
19661 {
19662 for (int l = 5; l < j - 5; l++)
19663 {
19664 if (Main.tile[k, l].active())
19665 {
19666 if (!patch)
19667 {
19668 return false;
19669 }
19670 int type = Main.tile[k, l].type;
19671 if (type != 2 && type != 0 && type != 1 && type != 191 && type != 192)
19672 {
19673 return false;
19674 }
19675 }
19676 }
19677 }
19678 int num8 = num3;
19679 int num9 = num4;
19680 int minl = num3;
19681 int minr = num4;
19682 bool flag2 = true;
19683 int num10 = genRand.Next(-8, -4);
19684 int num11 = genRand.Next(2);
19685 int num12 = j;
19686 int num13 = genRand.Next(5, 15);
19687 Main.tileSolid[48] = false;
19688 while (flag2)
19689 {
19690 num10++;
19691 if (num10 > num13)
19692 {
19693 num13 = genRand.Next(5, 15);
19694 num10 = 0;
19695 array2[num] = num12 + genRand.Next(5);
19696 if (genRand.Next(5) == 0)
19697 {
19698 num11 = ((num11 == 0) ? 1 : 0);
19699 }
19700 if (num11 == 0)
19701 {
19702 array3[num] = -1;
19703 array[num] = num3;
19704 array4[num] = num4 - num3;
19705 if (genRand.Next(2) == 0)
19706 {
19707 num3++;
19708 }
19709 num8++;
19710 num11 = 1;
19711 }
19712 else
19713 {
19714 array3[num] = 1;
19715 array[num] = num4;
19716 array4[num] = num4 - num3;
19717 if (genRand.Next(2) == 0)
19718 {
19719 num4--;
19720 }
19721 num9--;
19722 num11 = 0;
19723 }
19724 if (num8 == num9)
19725 {
19726 flag2 = false;
19727 }
19728 num++;
19729 }
19730 for (int m = num3; m <= num4; m++)
19731 {
19732 Main.tile[m, num12].type = 191;
19733 Main.tile[m, num12].active(active: true);
19734 Main.tile[m, num12].halfBrick(halfBrick: false);
19735 }
19736 num12--;
19737 }
19738 for (int n = 0; n < num - 1; n++)
19739 {
19740 int num14 = array[n] + array3[n];
19741 int num15 = array2[n];
19742 int num16 = (int)((double)array4[n] * (1.0 + (double)genRand.Next(20, 30) * 0.1));
19743 Main.tile[num14, num15 + 1].type = 191;
19744 Main.tile[num14, num15 + 1].active(active: true);
19745 Main.tile[num14, num15 + 1].halfBrick(halfBrick: false);
19746 int num17 = genRand.Next(3, 5);
19747 while (num16 > 0)
19748 {
19749 num16--;
19750 Main.tile[num14, num15].type = 191;
19751 Main.tile[num14, num15].active(active: true);
19752 Main.tile[num14, num15].halfBrick(halfBrick: false);
19753 if (genRand.Next(10) == 0)
19754 {
19755 num15 = ((genRand.Next(2) != 0) ? (num15 + 1) : (num15 - 1));
19756 }
19757 else
19758 {
19759 num14 += array3[n];
19760 }
19761 if (num17 > 0)
19762 {
19763 num17--;
19764 }
19765 else if (genRand.Next(2) == 0)
19766 {
19767 num17 = genRand.Next(2, 5);
19768 if (genRand.Next(2) == 0)
19769 {
19770 Main.tile[num14, num15].type = 191;
19771 Main.tile[num14, num15].active(active: true);
19772 Main.tile[num14, num15].halfBrick(halfBrick: false);
19773 Main.tile[num14, num15 - 1].type = 191;
19774 Main.tile[num14, num15 - 1].active(active: true);
19775 Main.tile[num14, num15 - 1].halfBrick(halfBrick: false);
19776 array5[num2] = num14;
19777 array6[num2] = num15;
19778 num2++;
19779 }
19780 else
19781 {
19782 Main.tile[num14, num15].type = 191;
19783 Main.tile[num14, num15].active(active: true);
19784 Main.tile[num14, num15].halfBrick(halfBrick: false);
19785 Main.tile[num14, num15 + 1].type = 191;
19786 Main.tile[num14, num15 + 1].active(active: true);
19787 Main.tile[num14, num15 + 1].halfBrick(halfBrick: false);
19788 array5[num2] = num14;
19789 array6[num2] = num15;
19790 num2++;
19791 }
19792 }
19793 if (num16 == 0)
19794 {
19795 array5[num2] = num14;
19796 array6[num2] = num15;
19797 num2++;
19798 }
19799 }
19800 }
19801 int num18 = (num3 + num4) / 2;
19802 int num19 = num12;
19803 int num20 = genRand.Next(num5 * 3, num5 * 5);
19804 int num21 = 0;
19805 int num22 = 0;
19806 while (num20 > 0)
19807 {
19808 Main.tile[num18, num19].type = 191;
19809 Main.tile[num18, num19].active(active: true);
19810 Main.tile[num18, num19].halfBrick(halfBrick: false);
19811 if (num21 > 0)
19812 {
19813 num21--;
19814 }
19815 if (num22 > 0)
19816 {
19817 num22--;
19818 }
19819 for (int num23 = -1; num23 < 2; num23++)
19820 {
19821 if (num23 == 0 || ((num23 >= 0 || num21 != 0) && (num23 <= 0 || num22 != 0)) || genRand.Next(2) != 0)
19822 {
19823 continue;
19824 }
19825 int num24 = num18;
19826 int num25 = num19;
19827 int num26 = genRand.Next(num5, num5 * 3);
19828 if (num23 < 0)
19829 {
19830 num21 = genRand.Next(3, 5);
19831 }
19832 if (num23 > 0)
19833 {
19834 num22 = genRand.Next(3, 5);
19835 }
19836 int num27 = 0;
19837 while (num26 > 0)
19838 {
19839 num26--;
19840 num24 += num23;
19841 Main.tile[num24, num25].type = 191;
19842 Main.tile[num24, num25].active(active: true);
19843 Main.tile[num24, num25].halfBrick(halfBrick: false);
19844 if (num26 == 0)
19845 {
19846 array5[num2] = num24;
19847 array6[num2] = num25;
19848 array7[num2] = true;
19849 num2++;
19850 }
19851 if (genRand.Next(5) == 0)
19852 {
19853 num25 = ((genRand.Next(2) != 0) ? (num25 + 1) : (num25 - 1));
19854 Main.tile[num24, num25].type = 191;
19855 Main.tile[num24, num25].active(active: true);
19856 Main.tile[num24, num25].halfBrick(halfBrick: false);
19857 }
19858 if (num27 > 0)
19859 {
19860 num27--;
19861 }
19862 else if (genRand.Next(3) == 0)
19863 {
19864 num27 = genRand.Next(2, 4);
19865 int num28 = num24;
19866 int num29 = num25;
19867 num29 = ((genRand.Next(2) != 0) ? (num29 + 1) : (num29 - 1));
19868 Main.tile[num28, num29].type = 191;
19869 Main.tile[num28, num29].active(active: true);
19870 Main.tile[num28, num29].halfBrick(halfBrick: false);
19871 array5[num2] = num28;
19872 array6[num2] = num29;
19873 array7[num2] = true;
19874 num2++;
19875 array5[num2] = num28 + genRand.Next(-5, 6);
19876 array6[num2] = num29 + genRand.Next(-5, 6);
19877 array7[num2] = true;
19878 num2++;
19879 }
19880 }
19881 }
19882 array5[num2] = num18;
19883 array6[num2] = num19;
19884 num2++;
19885 if (genRand.Next(4) == 0)
19886 {
19887 num18 = ((genRand.Next(2) != 0) ? (num18 + 1) : (num18 - 1));
19888 Main.tile[num18, num19].type = 191;
19889 Main.tile[num18, num19].active(active: true);
19890 Main.tile[num18, num19].halfBrick(halfBrick: false);
19891 }
19892 num19--;
19893 num20--;
19894 }
19895 for (int num30 = minl; num30 <= minr; num30++)
19896 {
19897 int num31 = genRand.Next(1, 6);
19898 int num32 = j + 1;
19899 while (num31 > 0)
19900 {
19901 if (SolidTile(num30, num32))
19902 {
19903 num31--;
19904 }
19905 Main.tile[num30, num32].type = 191;
19906 Main.tile[num30, num32].active(active: true);
19907 Main.tile[num30, num32].halfBrick(halfBrick: false);
19908 num32++;
19909 }
19910 int num33 = num32;
19911 int num34 = genRand.Next(2, num5 + 1);
19912 for (int num35 = 0; num35 < num34; num35++)
19913 {
19914 num32 = num33;
19915 int num36 = (minl + minr) / 2;
19916 int num37 = 0;
19917 int num38 = 1;
19918 num37 = ((num30 >= num36) ? 1 : (-1));
19919 if (num30 == num36 || (num5 > 6 && (num30 == num36 - 1 || num30 == num36 + 1)))
19920 {
19921 num37 = 0;
19922 }
19923 int num39 = num37;
19924 int num40 = num30;
19925 num31 = genRand.Next((int)((double)num5 * 3.5), num5 * 6);
19926 while (num31 > 0)
19927 {
19928 num31--;
19929 num40 += num37;
19930 if (Main.tile[num40, num32].wall != 244)
19931 {
19932 Main.tile[num40, num32].type = 191;
19933 Main.tile[num40, num32].active(active: true);
19934 Main.tile[num40, num32].halfBrick(halfBrick: false);
19935 }
19936 num32 += num38;
19937 if (Main.tile[num40, num32].wall != 244)
19938 {
19939 Main.tile[num40, num32].type = 191;
19940 Main.tile[num40, num32].active(active: true);
19941 Main.tile[num40, num32].halfBrick(halfBrick: false);
19942 }
19943 if (!Main.tile[num40, num32 + 1].active())
19944 {
19945 num37 = 0;
19946 num38 = 1;
19947 }
19948 if (genRand.Next(3) == 0)
19949 {
19950 num37 = ((num39 < 0) ? ((num37 == 0) ? (-1) : 0) : ((num39 <= 0) ? genRand.Next(-1, 2) : ((num37 == 0) ? 1 : 0)));
19951 }
19952 if (genRand.Next(3) == 0)
19953 {
19954 num38 = ((num38 == 0) ? 1 : 0);
19955 }
19956 }
19957 }
19958 }
19959 if (remixWorldGen)
19960 {
19961 num2 = 0;
19962 }
19963 for (int num41 = 0; num41 < num2; num41++)
19964 {
19965 int num42 = genRand.Next(5, 8);
19966 num42 = (int)((double)num42 * (1.0 + (double)num5 * 0.05));
19967 if (array7[num41])
19968 {
19969 num42 = genRand.Next(6, 12) + num5;
19970 }
19971 int num43 = array5[num41] - num42 * 2;
19972 int num44 = array5[num41] + num42 * 2;
19973 int num45 = array6[num41] - num42 * 2;
19974 int num46 = array6[num41] + num42 * 2;
19975 double num47 = 2.0 - (double)genRand.Next(5) * 0.1;
19976 for (int num48 = num43; num48 <= num44; num48++)
19977 {
19978 for (int num49 = num45; num49 <= num46; num49++)
19979 {
19980 if (Main.tile[num48, num49].type == 191)
19981 {
19982 continue;
19983 }
19984 if (array7[num41])
19985 {
19986 Vector2D val = new Vector2D((double)array5[num41], (double)array6[num41]) - new Vector2D((double)num48, (double)num49);
19987 if (((Vector2D)(ref val)).Length() < (double)num42 * 0.9)
19988 {
19989 Main.tile[num48, num49].type = 192;
19990 Main.tile[num48, num49].active(active: true);
19991 Main.tile[num48, num49].halfBrick(halfBrick: false);
19992 }
19993 }
19994 else if ((double)Math.Abs(array5[num41] - num48) + (double)Math.Abs(array6[num41] - num49) * num47 < (double)num42)
19995 {
19996 Main.tile[num48, num49].type = 192;
19997 Main.tile[num48, num49].active(active: true);
19998 Main.tile[num48, num49].halfBrick(halfBrick: false);
19999 }
20000 }
20001 if (genRand.Next(30) == 0)
20002 {
20003 int num50 = num45;
20004 if (!Main.tile[num48, num50].active())
20005 {
20006 for (; !Main.tile[num48, num50 + 1].active() && num50 < num46; num50++)
20007 {
20008 }
20009 if (Main.tile[num48, num50 + 1].type == 192)
20010 {
20011 PlaceTile(num48, num50, 187, mute: true, forced: false, -1, genRand.Next(50, 52));
20012 }
20013 }
20014 }
20015 if (array7[num41] || genRand.Next(15) != 0)
20016 {
20017 continue;
20018 }
20019 int num51 = num46;
20020 int num52 = num51 + 100;
20021 if (Main.tile[num48, num51].active())
20022 {
20023 continue;
20024 }
20025 for (; !Main.tile[num48, num51 + 1].active() && num51 < num52; num51++)
20026 {
20027 }
20028 if (Main.tile[num48, num51 + 1].type == 192)
20029 {
20030 continue;
20031 }
20032 if (genRand.Next(2) == 0)
20033 {
20034 PlaceTile(num48, num51, 187, mute: true, forced: false, -1, genRand.Next(47, 50));
20035 continue;
20036 }
20037 int num53 = genRand.Next(2);
20038 int x = 72;
20039 if (num53 == 1)
20040 {
20041 x = genRand.Next(59, 62);
20042 }
20043 PlaceSmallPile(num48, num51, x, num53, 185);
20044 }
20045 }
20046 if (flag)
20047 {
20048 bool flag3 = false;
20049 for (int num54 = j; num54 < j + 20 && !((double)num54 >= Main.worldSurface - 2.0); num54++)
20050 {
20051 for (int num55 = minl; num55 <= minr; num55++)
20052 {
20053 if (Main.tile[num55, num54].wall == 0 && !SolidTile(num55, num54))
20054 {
20055 flag3 = true;
20056 }
20057 }
20058 }
20059 if (!flag3)
20060 {
20061 GrowLivingTree_MakePassage(j, num5, ref minl, ref minr, patch);
20062 }
20063 }
20064 Main.tileSolid[48] = true;
20065 return true;
20066 }
System.Math.Abs
static double Abs(double value)
Terraria.ID.TileID.Sets.Ore
static bool[] Ore
Definition TileID.cs:295
Terraria.WorldGen.remixWorldGen
static bool remixWorldGen
Definition WorldGen.cs:1148
Terraria.WorldGen.PlaceSmallPile
static bool PlaceSmallPile(int i, int j, int X, int Y, ushort type=185)
Definition WorldGen.cs:37851
Terraria.WorldGen.PlaceTile
static bool PlaceTile(int i, int j, int Type, bool mute=false, bool forced=false, int plr=-1, int style=0)
Definition WorldGen.cs:50270
Terraria.WorldGen.genRand
static UnifiedRandom genRand
Definition WorldGen.cs:1215
Terraria.WorldGen.GrowLivingTree_MakePassage
static void GrowLivingTree_MakePassage(int j, int W, ref int minl, ref int minr, bool noSecretRoom=false)
Definition WorldGen.cs:20817
Terraria.WorldGen.notTheBees
static bool notTheBees
Definition WorldGen.cs:1164

References System.Math.Abs(), System.array, Terraria.ID.TileID.Sets.Ore, Terraria.Enums.SolidTile, Terraria.Main.tile, Terraria.Main.tileSolid, System.type, and Terraria.Main.worldSurface.