Advertisement
Guest User

Untitled

a guest
Jul 18th, 2014
588
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 124.37 KB | None | 0 0
  1. // Terraria.Player
  2. public void UpdateBuffs(int i)
  3. {
  4.     int[] array = new int[423];
  5.     for (int j = 0; j < 1000; j++)
  6.     {
  7.         if (Main.projectile[j].active && Main.projectile[j].owner == i)
  8.         {
  9.             array[Main.projectile[j].type]++;
  10.         }
  11.     }
  12.     for (int k = 0; k < 22; k++)
  13.     {
  14.         if (this.buffType[k] > 0 && this.buffTime[k] > 0)
  15.         {
  16.             if (this.whoAmi == Main.myPlayer && this.buffType[k] != 28)
  17.             {
  18.                 this.buffTime[k]--;
  19.             }
  20.             if (this.buffType[k] == 1)
  21.             {
  22.                 this.lavaImmune = true;
  23.                 this.fireWalk = true;
  24.             }
  25.             else
  26.             {
  27.                 if (this.buffType[k] == 2)
  28.                 {
  29.                     this.lifeRegen += 2;
  30.                 }
  31.                 else
  32.                 {
  33.                     if (this.buffType[k] == 3)
  34.                     {
  35.                         this.moveSpeed += 0.25f;
  36.                     }
  37.                     else
  38.                     {
  39.                         if (this.buffType[k] == 4)
  40.                         {
  41.                             this.gills = true;
  42.                         }
  43.                         else
  44.                         {
  45.                             if (this.buffType[k] == 5)
  46.                             {
  47.                                 this.statDefense += 8;
  48.                             }
  49.                             else
  50.                             {
  51.                                 if (this.buffType[k] == 6)
  52.                                 {
  53.                                     this.manaRegenBuff = true;
  54.                                 }
  55.                                 else
  56.                                 {
  57.                                     if (this.buffType[k] == 7)
  58.                                     {
  59.                                         this.magicDamage += 0.2f;
  60.                                     }
  61.                                     else
  62.                                     {
  63.                                         if (this.buffType[k] == 8)
  64.                                         {
  65.                                             this.slowFall = true;
  66.                                         }
  67.                                         else
  68.                                         {
  69.                                             if (this.buffType[k] == 9)
  70.                                             {
  71.                                                 this.findTreasure = true;
  72.                                             }
  73.                                             else
  74.                                             {
  75.                                                 if (this.buffType[k] == 10)
  76.                                                 {
  77.                                                     this.invis = true;
  78.                                                 }
  79.                                                 else
  80.                                                 {
  81.                                                     if (this.buffType[k] == 11)
  82.                                                     {
  83.                                                         Lighting.addLight((int)(this.position.X + (float)(this.width / 2)) / 16, (int)(this.position.Y + (float)(this.height / 2)) / 16, 0.8f, 0.95f, 1f);
  84.                                                     }
  85.                                                     else
  86.                                                     {
  87.                                                         if (this.buffType[k] == 12)
  88.                                                         {
  89.                                                             this.nightVision = true;
  90.                                                         }
  91.                                                         else
  92.                                                         {
  93.                                                             if (this.buffType[k] == 13)
  94.                                                             {
  95.                                                                 this.enemySpawns = true;
  96.                                                             }
  97.                                                             else
  98.                                                             {
  99.                                                                 if (this.buffType[k] == 14)
  100.                                                                 {
  101.                                                                     this.thorns = true;
  102.                                                                 }
  103.                                                                 else
  104.                                                                 {
  105.                                                                     if (this.buffType[k] == 15)
  106.                                                                     {
  107.                                                                         this.waterWalk = true;
  108.                                                                     }
  109.                                                                     else
  110.                                                                     {
  111.                                                                         if (this.buffType[k] == 16)
  112.                                                                         {
  113.                                                                             this.archery = true;
  114.                                                                         }
  115.                                                                         else
  116.                                                                         {
  117.                                                                             if (this.buffType[k] == 17)
  118.                                                                             {
  119.                                                                                 this.detectCreature = true;
  120.                                                                             }
  121.                                                                             else
  122.                                                                             {
  123.                                                                                 if (this.buffType[k] == 18)
  124.                                                                                 {
  125.                                                                                     this.gravControl = true;
  126.                                                                                 }
  127.                                                                                 else
  128.                                                                                 {
  129.                                                                                     if (this.buffType[k] == 30)
  130.                                                                                     {
  131.                                                                                         this.bleed = true;
  132.                                                                                     }
  133.                                                                                     else
  134.                                                                                     {
  135.                                                                                         if (this.buffType[k] == 31)
  136.                                                                                         {
  137.                                                                                             this.confused = true;
  138.                                                                                         }
  139.                                                                                         else
  140.                                                                                         {
  141.                                                                                             if (this.buffType[k] == 32)
  142.                                                                                             {
  143.                                                                                                 this.slow = true;
  144.                                                                                             }
  145.                                                                                             else
  146.                                                                                             {
  147.                                                                                                 if (this.buffType[k] == 35)
  148.                                                                                                 {
  149.                                                                                                     this.silence = true;
  150.                                                                                                 }
  151.                                                                                                 else
  152.                                                                                                 {
  153.                                                                                                     if (this.buffType[k] == 46)
  154.                                                                                                     {
  155.                                                                                                         this.chilled = true;
  156.                                                                                                     }
  157.                                                                                                     else
  158.                                                                                                     {
  159.                                                                                                         if (this.buffType[k] == 47)
  160.                                                                                                         {
  161.                                                                                                             this.frozen = true;
  162.                                                                                                         }
  163.                                                                                                         else
  164.                                                                                                         {
  165.                                                                                                             if (this.buffType[k] == 69)
  166.                                                                                                             {
  167.                                                                                                                 this.ichor = true;
  168.                                                                                                                 this.statDefense -= 20;
  169.                                                                                                             }
  170.                                                                                                             else
  171.                                                                                                             {
  172.                                                                                                                 if (this.buffType[k] == 36)
  173.                                                                                                                 {
  174.                                                                                                                     this.brokenArmor = true;
  175.                                                                                                                 }
  176.                                                                                                                 else
  177.                                                                                                                 {
  178.                                                                                                                     if (this.buffType[k] == 48)
  179.                                                                                                                     {
  180.                                                                                                                         this.honey = true;
  181.                                                                                                                     }
  182.                                                                                                                     else
  183.                                                                                                                     {
  184.                                                                                                                         if (this.buffType[k] == 59)
  185.                                                                                                                         {
  186.                                                                                                                             this.shadowDodge = true;
  187.                                                                                                                         }
  188.                                                                                                                         else
  189.                                                                                                                         {
  190.                                                                                                                             if (this.buffType[k] == 93)
  191.                                                                                                                             {
  192.                                                                                                                                 this.ammoBox = true;
  193.                                                                                                                             }
  194.                                                                                                                             else
  195.                                                                                                                             {
  196.                                                                                                                                 if (this.buffType[k] == 58)
  197.                                                                                                                                 {
  198.                                                                                                                                     this.palladiumRegen = true;
  199.                                                                                                                                 }
  200.                                                                                                                                 else
  201.                                                                                                                                 {
  202.                                                                                                                                     if (this.buffType[k] == 88)
  203.                                                                                                                                     {
  204.                                                                                                                                         this.chaosState = true;
  205.                                                                                                                                     }
  206.                                                                                                                                     else
  207.                                                                                                                                     {
  208.                                                                                                                                         if (this.buffType[k] == 63)
  209.                                                                                                                                         {
  210.                                                                                                                                             this.moveSpeed += 1f;
  211.                                                                                                                                         }
  212.                                                                                                                                         else
  213.                                                                                                                                         {
  214.                                                                                                                                             if (this.buffType[k] == 104)
  215.                                                                                                                                             {
  216.                                                                                                                                                 this.pickSpeed -= 0.25f;
  217.                                                                                                                                             }
  218.                                                                                                                                             else
  219.                                                                                                                                             {
  220.                                                                                                                                                 if (this.buffType[k] == 105)
  221.                                                                                                                                                 {
  222.                                                                                                                                                     this.lifeMagnet = true;
  223.                                                                                                                                                 }
  224.                                                                                                                                                 else
  225.                                                                                                                                                 {
  226.                                                                                                                                                     if (this.buffType[k] == 106)
  227.                                                                                                                                                     {
  228.                                                                                                                                                         this.calmed = true;
  229.                                                                                                                                                     }
  230.                                                                                                                                                     else
  231.                                                                                                                                                     {
  232.                                                                                                                                                         if (this.buffType[k] == 121)
  233.                                                                                                                                                         {
  234.                                                                                                                                                             this.fishingSkill += 15;
  235.                                                                                                                                                         }
  236.                                                                                                                                                         else
  237.                                                                                                                                                         {
  238.                                                                                                                                                             if (this.buffType[k] == 122)
  239.                                                                                                                                                             {
  240.                                                                                                                                                                 this.sonarPotion = true;
  241.                                                                                                                                                             }
  242.                                                                                                                                                             else
  243.                                                                                                                                                             {
  244.                                                                                                                                                                 if (this.buffType[k] == 123)
  245.                                                                                                                                                                 {
  246.                                                                                                                                                                     this.cratePotion = true;
  247.                                                                                                                                                                 }
  248.                                                                                                                                                                 else
  249.                                                                                                                                                                 {
  250.                                                                                                                                                                     if (this.buffType[k] == 107)
  251.                                                                                                                                                                     {
  252.                                                                                                                                                                         this.tileSpeed += 0.25f;
  253.                                                                                                                                                                         this.wallSpeed += 0.25f;
  254.                                                                                                                                                                         this.blockRange++;
  255.                                                                                                                                                                     }
  256.                                                                                                                                                                     else
  257.                                                                                                                                                                     {
  258.                                                                                                                                                                         if (this.buffType[k] == 108)
  259.                                                                                                                                                                         {
  260.                                                                                                                                                                             this.kbBuff = true;
  261.                                                                                                                                                                         }
  262.                                                                                                                                                                         else
  263.                                                                                                                                                                         {
  264.                                                                                                                                                                             if (this.buffType[k] == 109)
  265.                                                                                                                                                                             {
  266.                                                                                                                                                                                 this.ignoreWater = true;
  267.                                                                                                                                                                                 this.accFlipper = true;
  268.                                                                                                                                                                             }
  269.                                                                                                                                                                             else
  270.                                                                                                                                                                             {
  271.                                                                                                                                                                                 if (this.buffType[k] == 110)
  272.                                                                                                                                                                                 {
  273.                                                                                                                                                                                     this.maxMinions++;
  274.                                                                                                                                                                                 }
  275.                                                                                                                                                                                 else
  276.                                                                                                                                                                                 {
  277.                                                                                                                                                                                     if (this.buffType[k] == 111)
  278.                                                                                                                                                                                     {
  279.                                                                                                                                                                                         this.dangerSense = true;
  280.                                                                                                                                                                                     }
  281.                                                                                                                                                                                     else
  282.                                                                                                                                                                                     {
  283.                                                                                                                                                                                         if (this.buffType[k] == 112)
  284.                                                                                                                                                                                         {
  285.                                                                                                                                                                                             this.ammoPotion = true;
  286.                                                                                                                                                                                         }
  287.                                                                                                                                                                                         else
  288.                                                                                                                                                                                         {
  289.                                                                                                                                                                                             if (this.buffType[k] == 113)
  290.                                                                                                                                                                                             {
  291.                                                                                                                                                                                                 this.lifeForce = true;
  292.                                                                                                                                                                                                 this.statLifeMax2 += this.statLifeMax / 5 / 20 * 20;
  293.                                                                                                                                                                                             }
  294.                                                                                                                                                                                             else
  295.                                                                                                                                                                                             {
  296.                                                                                                                                                                                                 if (this.buffType[k] == 114)
  297.                                                                                                                                                                                                 {
  298.                                                                                                                                                                                                     this.endurance += 0.1f;
  299.                                                                                                                                                                                                 }
  300.                                                                                                                                                                                                 else
  301.                                                                                                                                                                                                 {
  302.                                                                                                                                                                                                     if (this.buffType[k] == 115)
  303.                                                                                                                                                                                                     {
  304.                                                                                                                                                                                                         this.meleeCrit += 10;
  305.                                                                                                                                                                                                         this.rangedCrit += 10;
  306.                                                                                                                                                                                                         this.magicCrit += 10;
  307.                                                                                                                                                                                                     }
  308.                                                                                                                                                                                                     else
  309.                                                                                                                                                                                                     {
  310.                                                                                                                                                                                                         if (this.buffType[k] == 116)
  311.                                                                                                                                                                                                         {
  312.                                                                                                                                                                                                             this.inferno = true;
  313.                                                                                                                                                                                                             Lighting.addLight((int)(this.Center().X / 16f), (int)(this.Center().Y / 16f), 0.65f, 0.4f, 0.1f);
  314.                                                                                                                                                                                                             int num = 24;
  315.                                                                                                                                                                                                             float num2 = 200f;
  316.                                                                                                                                                                                                             bool flag = this.infernoCounter % 60 == 0;
  317.                                                                                                                                                                                                             int num3 = 10;
  318.                                                                                                                                                                                                             if (this.whoAmi == Main.myPlayer)
  319.                                                                                                                                                                                                             {
  320.                                                                                                                                                                                                                 for (int l = 0; l < 200; l++)
  321.                                                                                                                                                                                                                 {
  322.                                                                                                                                                                                                                     NPC nPC = Main.npc[l];
  323.                                                                                                                                                                                                                     if (nPC.active && !nPC.friendly && nPC.damage > 0 && !nPC.dontTakeDamage && !nPC.buffImmune[num] && Vector2.Distance(this.center(), nPC.center()) <= num2)
  324.                                                                                                                                                                                                                     {
  325.                                                                                                                                                                                                                         if (nPC.HasBuff(num) == -1)
  326.                                                                                                                                                                                                                         {
  327.                                                                                                                                                                                                                             nPC.AddBuff(num, 120, false);
  328.                                                                                                                                                                                                                         }
  329.                                                                                                                                                                                                                         if (flag)
  330.                                                                                                                                                                                                                         {
  331.                                                                                                                                                                                                                             nPC.StrikeNPC(num3, 0f, 0, false, false);
  332.                                                                                                                                                                                                                             if (Main.netMode != 0)
  333.                                                                                                                                                                                                                             {
  334.                                                                                                                                                                                                                                 NetMessage.SendData(28, -1, -1, "", l, (float)num3, 0f, 0f, 0);
  335.                                                                                                                                                                                                                             }
  336.                                                                                                                                                                                                                         }
  337.                                                                                                                                                                                                                     }
  338.                                                                                                                                                                                                                 }
  339.                                                                                                                                                                                                                 if (this.hostile)
  340.                                                                                                                                                                                                                 {
  341.                                                                                                                                                                                                                     for (int m = 0; m < 255; m++)
  342.                                                                                                                                                                                                                     {
  343.                                                                                                                                                                                                                         Player player = Main.player[m];
  344.                                                                                                                                                                                                                         if (player != this && player.active && !player.dead && player.hostile && !player.buffImmune[num] && (player.team != this.team || player.team == 0) && Vector2.Distance(this.center(), player.center()) <= num2)
  345.                                                                                                                                                                                                                         {
  346.                                                                                                                                                                                                                             if (player.HasBuff(num) == -1)
  347.                                                                                                                                                                                                                             {
  348.                                                                                                                                                                                                                                 player.AddBuff(num, 120, true);
  349.                                                                                                                                                                                                                             }
  350.                                                                                                                                                                                                                             if (flag)
  351.                                                                                                                                                                                                                             {
  352.                                                                                                                                                                                                                                 player.Hurt(num3, 0, true, false, "", false);
  353.                                                                                                                                                                                                                                 if (Main.netMode != 0)
  354.                                                                                                                                                                                                                                 {
  355.                                                                                                                                                                                                                                     NetMessage.SendData(26, -1, -1, Lang.deathMsg(this.whoAmi, -1, -1, -1), m, 0f, (float)num3, 1f, 0);
  356.                                                                                                                                                                                                                                 }
  357.                                                                                                                                                                                                                             }
  358.                                                                                                                                                                                                                         }
  359.                                                                                                                                                                                                                     }
  360.                                                                                                                                                                                                                 }
  361.                                                                                                                                                                                                             }
  362.                                                                                                                                                                                                         }
  363.                                                                                                                                                                                                         else
  364.                                                                                                                                                                                                         {
  365.                                                                                                                                                                                                             if (this.buffType[k] == 117)
  366.                                                                                                                                                                                                             {
  367.                                                                                                                                                                                                                 this.meleeDamage += 0.1f;
  368.                                                                                                                                                                                                                 this.rangedDamage += 0.1f;
  369.                                                                                                                                                                                                                 this.magicDamage += 0.1f;
  370.                                                                                                                                                                                                                 this.minionDamage += 0.1f;
  371.                                                                                                                                                                                                             }
  372.                                                                                                                                                                                                             else
  373.                                                                                                                                                                                                             {
  374.                                                                                                                                                                                                                 if (this.buffType[k] == 119)
  375.                                                                                                                                                                                                                 {
  376.                                                                                                                                                                                                                     this.loveStruck = true;
  377.                                                                                                                                                                                                                 }
  378.                                                                                                                                                                                                                 else
  379.                                                                                                                                                                                                                 {
  380.                                                                                                                                                                                                                     if (this.buffType[k] == 120)
  381.                                                                                                                                                                                                                     {
  382.                                                                                                                                                                                                                         this.stinky = true;
  383.                                                                                                                                                                                                                     }
  384.                                                                                                                                                                                                                     else
  385.                                                                                                                                                                                                                     {
  386.                                                                                                                                                                                                                         if (this.buffType[k] == 124)
  387.                                                                                                                                                                                                                         {
  388.                                                                                                                                                                                                                             this.resistCold = true;
  389.                                                                                                                                                                                                                         }
  390.                                                                                                                                                                                                                         else
  391.                                                                                                                                                                                                                         {
  392.                                                                                                                                                                                                                             if (this.buffType[k] == 94)
  393.                                                                                                                                                                                                                             {
  394.                                                                                                                                                                                                                                 this.manaSick = true;
  395.                                                                                                                                                                                                                                 this.manaSickReduction = Player.manaSickLessDmg * ((float)this.buffTime[k] / (float)Player.manaSickTime);
  396.                                                                                                                                                                                                                             }
  397.                                                                                                                                                                                                                             else
  398.                                                                                                                                                                                                                             {
  399.                                                                                                                                                                                                                                 if (this.buffType[k] >= 95 && this.buffType[k] <= 97)
  400.                                                                                                                                                                                                                                 {
  401.                                                                                                                                                                                                                                     this.buffTime[k] = 5;
  402.                                                                                                                                                                                                                                     int num4 = (int)((byte)(1 + this.buffType[k] - 95));
  403.                                                                                                                                                                                                                                     if (this.beetleOrbs > 0 && this.beetleOrbs != num4)
  404.                                                                                                                                                                                                                                     {
  405.                                                                                                                                                                                                                                         if (this.beetleOrbs > num4)
  406.                                                                                                                                                                                                                                         {
  407.                                                                                                                                                                                                                                             this.DelBuff(k);
  408.                                                                                                                                                                                                                                         }
  409.                                                                                                                                                                                                                                         else
  410.                                                                                                                                                                                                                                         {
  411.                                                                                                                                                                                                                                             for (int n = 0; n < 22; n++)
  412.                                                                                                                                                                                                                                             {
  413.                                                                                                                                                                                                                                                 if (this.buffType[n] >= 95 && this.buffType[n] <= 95 + num4 - 1)
  414.                                                                                                                                                                                                                                                 {
  415.                                                                                                                                                                                                                                                     this.DelBuff(n);
  416.                                                                                                                                                                                                                                                 }
  417.                                                                                                                                                                                                                                             }
  418.                                                                                                                                                                                                                                         }
  419.                                                                                                                                                                                                                                     }
  420.                                                                                                                                                                                                                                     this.beetleOrbs = num4;
  421.                                                                                                                                                                                                                                     if (!this.beetleDefense)
  422.                                                                                                                                                                                                                                     {
  423.                                                                                                                                                                                                                                         this.beetleOrbs = 0;
  424.                                                                                                                                                                                                                                         this.DelBuff(k);
  425.                                                                                                                                                                                                                                     }
  426.                                                                                                                                                                                                                                     else
  427.                                                                                                                                                                                                                                     {
  428.                                                                                                                                                                                                                                         this.beetleBuff = true;
  429.                                                                                                                                                                                                                                     }
  430.                                                                                                                                                                                                                                 }
  431.                                                                                                                                                                                                                                 else
  432.                                                                                                                                                                                                                                 {
  433.                                                                                                                                                                                                                                     if (this.buffType[k] >= 98 && this.buffType[k] <= 100)
  434.                                                                                                                                                                                                                                     {
  435.                                                                                                                                                                                                                                         int num5 = (int)((byte)(1 + this.buffType[k] - 98));
  436.                                                                                                                                                                                                                                         if (this.beetleOrbs > 0 && this.beetleOrbs != num5)
  437.                                                                                                                                                                                                                                         {
  438.                                                                                                                                                                                                                                             if (this.beetleOrbs > num5)
  439.                                                                                                                                                                                                                                             {
  440.                                                                                                                                                                                                                                                 this.DelBuff(k);
  441.                                                                                                                                                                                                                                             }
  442.                                                                                                                                                                                                                                             else
  443.                                                                                                                                                                                                                                             {
  444.                                                                                                                                                                                                                                                 for (int num6 = 0; num6 < 22; num6++)
  445.                                                                                                                                                                                                                                                 {
  446.                                                                                                                                                                                                                                                     if (this.buffType[num6] >= 98 && this.buffType[num6] <= 98 + num5 - 1)
  447.                                                                                                                                                                                                                                                     {
  448.                                                                                                                                                                                                                                                         this.DelBuff(num6);
  449.                                                                                                                                                                                                                                                     }
  450.                                                                                                                                                                                                                                                 }
  451.                                                                                                                                                                                                                                             }
  452.                                                                                                                                                                                                                                         }
  453.                                                                                                                                                                                                                                         this.beetleOrbs = num5;
  454.                                                                                                                                                                                                                                         this.meleeDamage += 0.1f * (float)this.beetleOrbs;
  455.                                                                                                                                                                                                                                         this.meleeSpeed += 0.1f * (float)this.beetleOrbs;
  456.                                                                                                                                                                                                                                         if (!this.beetleOffense)
  457.                                                                                                                                                                                                                                         {
  458.                                                                                                                                                                                                                                             this.beetleOrbs = 0;
  459.                                                                                                                                                                                                                                             this.DelBuff(k);
  460.                                                                                                                                                                                                                                         }
  461.                                                                                                                                                                                                                                         else
  462.                                                                                                                                                                                                                                         {
  463.                                                                                                                                                                                                                                             this.beetleBuff = true;
  464.                                                                                                                                                                                                                                         }
  465.                                                                                                                                                                                                                                     }
  466.                                                                                                                                                                                                                                     else
  467.                                                                                                                                                                                                                                     {
  468.                                                                                                                                                                                                                                         if (this.buffType[k] == 62)
  469.                                                                                                                                                                                                                                         {
  470.                                                                                                                                                                                                                                             if ((double)this.statLife <= (double)this.statLifeMax2 * 0.25)
  471.                                                                                                                                                                                                                                             {
  472.                                                                                                                                                                                                                                                 Lighting.addLight((int)(this.Center().X / 16f), (int)(this.Center().Y / 16f), 0.1f, 0.2f, 0.45f);
  473.                                                                                                                                                                                                                                                 this.iceBarrier = true;
  474.                                                                                                                                                                                                                                                 this.statDefense += 30;
  475.                                                                                                                                                                                                                                                 this.iceBarrierFrameCounter += 1;
  476.                                                                                                                                                                                                                                                 if (this.iceBarrierFrameCounter > 2)
  477.                                                                                                                                                                                                                                                 {
  478.                                                                                                                                                                                                                                                     this.iceBarrierFrameCounter = 0;
  479.                                                                                                                                                                                                                                                     this.iceBarrierFrame += 1;
  480.                                                                                                                                                                                                                                                     if (this.iceBarrierFrame >= 12)
  481.                                                                                                                                                                                                                                                     {
  482.                                                                                                                                                                                                                                                         this.iceBarrierFrame = 0;
  483.                                                                                                                                                                                                                                                     }
  484.                                                                                                                                                                                                                                                 }
  485.                                                                                                                                                                                                                                             }
  486.                                                                                                                                                                                                                                             else
  487.                                                                                                                                                                                                                                             {
  488.                                                                                                                                                                                                                                                 this.DelBuff(k);
  489.                                                                                                                                                                                                                                             }
  490.                                                                                                                                                                                                                                         }
  491.                                                                                                                                                                                                                                         else
  492.                                                                                                                                                                                                                                         {
  493.                                                                                                                                                                                                                                             if (this.buffType[k] == 49)
  494.                                                                                                                                                                                                                                             {
  495.                                                                                                                                                                                                                                                 for (int num7 = 191; num7 <= 194; num7++)
  496.                                                                                                                                                                                                                                                 {
  497.                                                                                                                                                                                                                                                     if (array[num7] > 0)
  498.                                                                                                                                                                                                                                                     {
  499.                                                                                                                                                                                                                                                         this.pygmy = true;
  500.                                                                                                                                                                                                                                                     }
  501.                                                                                                                                                                                                                                                 }
  502.                                                                                                                                                                                                                                                 if (!this.pygmy)
  503.                                                                                                                                                                                                                                                 {
  504.                                                                                                                                                                                                                                                     this.DelBuff(k);
  505.                                                                                                                                                                                                                                                 }
  506.                                                                                                                                                                                                                                                 else
  507.                                                                                                                                                                                                                                                 {
  508.                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  509.                                                                                                                                                                                                                                                 }
  510.                                                                                                                                                                                                                                             }
  511.                                                                                                                                                                                                                                             else
  512.                                                                                                                                                                                                                                             {
  513.                                                                                                                                                                                                                                                 if (this.buffType[k] == 83)
  514.                                                                                                                                                                                                                                                 {
  515.                                                                                                                                                                                                                                                     if (array[317] > 0)
  516.                                                                                                                                                                                                                                                     {
  517.                                                                                                                                                                                                                                                         this.raven = true;
  518.                                                                                                                                                                                                                                                     }
  519.                                                                                                                                                                                                                                                     if (!this.raven)
  520.                                                                                                                                                                                                                                                     {
  521.                                                                                                                                                                                                                                                         this.DelBuff(k);
  522.                                                                                                                                                                                                                                                     }
  523.                                                                                                                                                                                                                                                     else
  524.                                                                                                                                                                                                                                                     {
  525.                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  526.                                                                                                                                                                                                                                                     }
  527.                                                                                                                                                                                                                                                 }
  528.                                                                                                                                                                                                                                                 else
  529.                                                                                                                                                                                                                                                 {
  530.                                                                                                                                                                                                                                                     if (this.buffType[k] == 64)
  531.                                                                                                                                                                                                                                                     {
  532.                                                                                                                                                                                                                                                         if (array[266] > 0)
  533.                                                                                                                                                                                                                                                         {
  534.                                                                                                                                                                                                                                                             this.slime = true;
  535.                                                                                                                                                                                                                                                         }
  536.                                                                                                                                                                                                                                                         if (!this.slime)
  537.                                                                                                                                                                                                                                                         {
  538.                                                                                                                                                                                                                                                             this.DelBuff(k);
  539.                                                                                                                                                                                                                                                         }
  540.                                                                                                                                                                                                                                                         else
  541.                                                                                                                                                                                                                                                         {
  542.                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  543.                                                                                                                                                                                                                                                         }
  544.                                                                                                                                                                                                                                                     }
  545.                                                                                                                                                                                                                                                     else
  546.                                                                                                                                                                                                                                                     {
  547.                                                                                                                                                                                                                                                         if (this.buffType[k] == 125)
  548.                                                                                                                                                                                                                                                         {
  549.                                                                                                                                                                                                                                                             if (array[373] > 0)
  550.                                                                                                                                                                                                                                                             {
  551.                                                                                                                                                                                                                                                                 this.hornetMinion = true;
  552.                                                                                                                                                                                                                                                             }
  553.                                                                                                                                                                                                                                                             if (!this.hornetMinion)
  554.                                                                                                                                                                                                                                                             {
  555.                                                                                                                                                                                                                                                                 this.DelBuff(k);
  556.                                                                                                                                                                                                                                                             }
  557.                                                                                                                                                                                                                                                             else
  558.                                                                                                                                                                                                                                                             {
  559.                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  560.                                                                                                                                                                                                                                                             }
  561.                                                                                                                                                                                                                                                         }
  562.                                                                                                                                                                                                                                                         else
  563.                                                                                                                                                                                                                                                         {
  564.                                                                                                                                                                                                                                                             if (this.buffType[k] == 126)
  565.                                                                                                                                                                                                                                                             {
  566.                                                                                                                                                                                                                                                                 if (array[375] > 0)
  567.                                                                                                                                                                                                                                                                 {
  568.                                                                                                                                                                                                                                                                     this.impMinion = true;
  569.                                                                                                                                                                                                                                                                 }
  570.                                                                                                                                                                                                                                                                 if (!this.impMinion)
  571.                                                                                                                                                                                                                                                                 {
  572.                                                                                                                                                                                                                                                                     this.DelBuff(k);
  573.                                                                                                                                                                                                                                                                 }
  574.                                                                                                                                                                                                                                                                 else
  575.                                                                                                                                                                                                                                                                 {
  576.                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  577.                                                                                                                                                                                                                                                                 }
  578.                                                                                                                                                                                                                                                             }
  579.                                                                                                                                                                                                                                                             else
  580.                                                                                                                                                                                                                                                             {
  581.                                                                                                                                                                                                                                                                 if (this.buffType[k] == 133)
  582.                                                                                                                                                                                                                                                                 {
  583.                                                                                                                                                                                                                                                                     if (array[390] > 0 || array[391] > 0 || array[392] > 0)
  584.                                                                                                                                                                                                                                                                     {
  585.                                                                                                                                                                                                                                                                         this.spiderMinion = true;
  586.                                                                                                                                                                                                                                                                     }
  587.                                                                                                                                                                                                                                                                     if (!this.spiderMinion)
  588.                                                                                                                                                                                                                                                                     {
  589.                                                                                                                                                                                                                                                                         this.DelBuff(k);
  590.                                                                                                                                                                                                                                                                     }
  591.                                                                                                                                                                                                                                                                     else
  592.                                                                                                                                                                                                                                                                     {
  593.                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  594.                                                                                                                                                                                                                                                                     }
  595.                                                                                                                                                                                                                                                                 }
  596.                                                                                                                                                                                                                                                                 else
  597.                                                                                                                                                                                                                                                                 {
  598.                                                                                                                                                                                                                                                                     if (this.buffType[k] == 134)
  599.                                                                                                                                                                                                                                                                     {
  600.                                                                                                                                                                                                                                                                         if (array[387] > 0 || array[388] > 0)
  601.                                                                                                                                                                                                                                                                         {
  602.                                                                                                                                                                                                                                                                             this.twinsMinion = true;
  603.                                                                                                                                                                                                                                                                         }
  604.                                                                                                                                                                                                                                                                         if (!this.twinsMinion)
  605.                                                                                                                                                                                                                                                                         {
  606.                                                                                                                                                                                                                                                                             this.DelBuff(k);
  607.                                                                                                                                                                                                                                                                         }
  608.                                                                                                                                                                                                                                                                         else
  609.                                                                                                                                                                                                                                                                         {
  610.                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  611.                                                                                                                                                                                                                                                                         }
  612.                                                                                                                                                                                                                                                                     }
  613.                                                                                                                                                                                                                                                                     else
  614.                                                                                                                                                                                                                                                                     {
  615.                                                                                                                                                                                                                                                                         if (this.buffType[k] == 135)
  616.                                                                                                                                                                                                                                                                         {
  617.                                                                                                                                                                                                                                                                             if (array[393] > 0 || array[394] > 0 || array[395] > 0)
  618.                                                                                                                                                                                                                                                                             {
  619.                                                                                                                                                                                                                                                                                 this.pirateMinion = true;
  620.                                                                                                                                                                                                                                                                             }
  621.                                                                                                                                                                                                                                                                             if (!this.pirateMinion)
  622.                                                                                                                                                                                                                                                                             {
  623.                                                                                                                                                                                                                                                                                 this.DelBuff(k);
  624.                                                                                                                                                                                                                                                                             }
  625.                                                                                                                                                                                                                                                                             else
  626.                                                                                                                                                                                                                                                                             {
  627.                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  628.                                                                                                                                                                                                                                                                             }
  629.                                                                                                                                                                                                                                                                         }
  630.                                                                                                                                                                                                                                                                         else
  631.                                                                                                                                                                                                                                                                         {
  632.                                                                                                                                                                                                                                                                             if (this.buffType[k] == 139)
  633.                                                                                                                                                                                                                                                                             {
  634.                                                                                                                                                                                                                                                                                 if (array[407] > 0)
  635.                                                                                                                                                                                                                                                                                 {
  636.                                                                                                                                                                                                                                                                                     this.sharknadoMinion = true;
  637.                                                                                                                                                                                                                                                                                 }
  638.                                                                                                                                                                                                                                                                                 if (!this.sharknadoMinion)
  639.                                                                                                                                                                                                                                                                                 {
  640.                                                                                                                                                                                                                                                                                     this.DelBuff(k);
  641.                                                                                                                                                                                                                                                                                 }
  642.                                                                                                                                                                                                                                                                                 else
  643.                                                                                                                                                                                                                                                                                 {
  644.                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  645.                                                                                                                                                                                                                                                                                 }
  646.                                                                                                                                                                                                                                                                             }
  647.                                                                                                                                                                                                                                                                             else
  648.                                                                                                                                                                                                                                                                             {
  649.                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 90)
  650.                                                                                                                                                                                                                                                                                 {
  651.                                                                                                                                                                                                                                                                                     this.mount.SetMount(0, this, false);
  652.                                                                                                                                                                                                                                                                                     this.buffTime[k] = 10;
  653.                                                                                                                                                                                                                                                                                 }
  654.                                                                                                                                                                                                                                                                                 else
  655.                                                                                                                                                                                                                                                                                 {
  656.                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 128)
  657.                                                                                                                                                                                                                                                                                     {
  658.                                                                                                                                                                                                                                                                                         this.mount.SetMount(1, this, false);
  659.                                                                                                                                                                                                                                                                                         this.buffTime[k] = 10;
  660.                                                                                                                                                                                                                                                                                     }
  661.                                                                                                                                                                                                                                                                                     else
  662.                                                                                                                                                                                                                                                                                     {
  663.                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 129)
  664.                                                                                                                                                                                                                                                                                         {
  665.                                                                                                                                                                                                                                                                                             this.mount.SetMount(2, this, false);
  666.                                                                                                                                                                                                                                                                                             this.buffTime[k] = 10;
  667.                                                                                                                                                                                                                                                                                         }
  668.                                                                                                                                                                                                                                                                                         else
  669.                                                                                                                                                                                                                                                                                         {
  670.                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 130)
  671.                                                                                                                                                                                                                                                                                             {
  672.                                                                                                                                                                                                                                                                                                 this.mount.SetMount(3, this, false);
  673.                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 10;
  674.                                                                                                                                                                                                                                                                                             }
  675.                                                                                                                                                                                                                                                                                             else
  676.                                                                                                                                                                                                                                                                                             {
  677.                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 118)
  678.                                                                                                                                                                                                                                                                                                 {
  679.                                                                                                                                                                                                                                                                                                     this.mount.SetMount(6, this, true);
  680.                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 10;
  681.                                                                                                                                                                                                                                                                                                 }
  682.                                                                                                                                                                                                                                                                                                 else
  683.                                                                                                                                                                                                                                                                                                 {
  684.                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 138)
  685.                                                                                                                                                                                                                                                                                                     {
  686.                                                                                                                                                                                                                                                                                                         this.mount.SetMount(6, this, false);
  687.                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 10;
  688.                                                                                                                                                                                                                                                                                                     }
  689.                                                                                                                                                                                                                                                                                                     else
  690.                                                                                                                                                                                                                                                                                                     {
  691.                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 131)
  692.                                                                                                                                                                                                                                                                                                         {
  693.                                                                                                                                                                                                                                                                                                             this.ignoreWater = true;
  694.                                                                                                                                                                                                                                                                                                             this.accFlipper = true;
  695.                                                                                                                                                                                                                                                                                                             this.mount.SetMount(4, this, false);
  696.                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 10;
  697.                                                                                                                                                                                                                                                                                                         }
  698.                                                                                                                                                                                                                                                                                                         else
  699.                                                                                                                                                                                                                                                                                                         {
  700.                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 132)
  701.                                                                                                                                                                                                                                                                                                             {
  702.                                                                                                                                                                                                                                                                                                                 this.mount.SetMount(5, this, false);
  703.                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 10;
  704.                                                                                                                                                                                                                                                                                                             }
  705.                                                                                                                                                                                                                                                                                                             else
  706.                                                                                                                                                                                                                                                                                                             {
  707.                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 37)
  708.                                                                                                                                                                                                                                                                                                                 {
  709.                                                                                                                                                                                                                                                                                                                     if (Main.wof >= 0 && Main.npc[Main.wof].type == 113)
  710.                                                                                                                                                                                                                                                                                                                     {
  711.                                                                                                                                                                                                                                                                                                                         this.gross = true;
  712.                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 10;
  713.                                                                                                                                                                                                                                                                                                                     }
  714.                                                                                                                                                                                                                                                                                                                     else
  715.                                                                                                                                                                                                                                                                                                                     {
  716.                                                                                                                                                                                                                                                                                                                         this.DelBuff(k);
  717.                                                                                                                                                                                                                                                                                                                     }
  718.                                                                                                                                                                                                                                                                                                                 }
  719.                                                                                                                                                                                                                                                                                                                 else
  720.                                                                                                                                                                                                                                                                                                                 {
  721.                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 38)
  722.                                                                                                                                                                                                                                                                                                                     {
  723.                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 10;
  724.                                                                                                                                                                                                                                                                                                                         this.tongued = true;
  725.                                                                                                                                                                                                                                                                                                                     }
  726.                                                                                                                                                                                                                                                                                                                     else
  727.                                                                                                                                                                                                                                                                                                                     {
  728.                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 19)
  729.                                                                                                                                                                                                                                                                                                                         {
  730.                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  731.                                                                                                                                                                                                                                                                                                                             this.lightOrb = true;
  732.                                                                                                                                                                                                                                                                                                                             bool flag2 = true;
  733.                                                                                                                                                                                                                                                                                                                             if (array[18] > 0)
  734.                                                                                                                                                                                                                                                                                                                             {
  735.                                                                                                                                                                                                                                                                                                                                 flag2 = false;
  736.                                                                                                                                                                                                                                                                                                                             }
  737.                                                                                                                                                                                                                                                                                                                             if (flag2)
  738.                                                                                                                                                                                                                                                                                                                             {
  739.                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 18, 0, 0f, this.whoAmi, 0f, 0f);
  740.                                                                                                                                                                                                                                                                                                                             }
  741.                                                                                                                                                                                                                                                                                                                         }
  742.                                                                                                                                                                                                                                                                                                                         else
  743.                                                                                                                                                                                                                                                                                                                         {
  744.                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 27 || this.buffType[k] == 101 || this.buffType[k] == 102)
  745.                                                                                                                                                                                                                                                                                                                             {
  746.                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  747.                                                                                                                                                                                                                                                                                                                                 bool flag3 = true;
  748.                                                                                                                                                                                                                                                                                                                                 int num8 = 72;
  749.                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 27)
  750.                                                                                                                                                                                                                                                                                                                                 {
  751.                                                                                                                                                                                                                                                                                                                                     this.blueFairy = true;
  752.                                                                                                                                                                                                                                                                                                                                 }
  753.                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 101)
  754.                                                                                                                                                                                                                                                                                                                                 {
  755.                                                                                                                                                                                                                                                                                                                                     num8 = 86;
  756.                                                                                                                                                                                                                                                                                                                                     this.redFairy = true;
  757.                                                                                                                                                                                                                                                                                                                                 }
  758.                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 102)
  759.                                                                                                                                                                                                                                                                                                                                 {
  760.                                                                                                                                                                                                                                                                                                                                     num8 = 87;
  761.                                                                                                                                                                                                                                                                                                                                     this.greenFairy = true;
  762.                                                                                                                                                                                                                                                                                                                                 }
  763.                                                                                                                                                                                                                                                                                                                                 if (this.head == 45 && this.body == 26 && this.legs == 25)
  764.                                                                                                                                                                                                                                                                                                                                 {
  765.                                                                                                                                                                                                                                                                                                                                     num8 = 72;
  766.                                                                                                                                                                                                                                                                                                                                 }
  767.                                                                                                                                                                                                                                                                                                                                 if (array[num8] > 0)
  768.                                                                                                                                                                                                                                                                                                                                 {
  769.                                                                                                                                                                                                                                                                                                                                     flag3 = false;
  770.                                                                                                                                                                                                                                                                                                                                 }
  771.                                                                                                                                                                                                                                                                                                                                 if (flag3)
  772.                                                                                                                                                                                                                                                                                                                                 {
  773.                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, num8, 0, 0f, this.whoAmi, 0f, 0f);
  774.                                                                                                                                                                                                                                                                                                                                 }
  775.                                                                                                                                                                                                                                                                                                                             }
  776.                                                                                                                                                                                                                                                                                                                             else
  777.                                                                                                                                                                                                                                                                                                                             {
  778.                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 40)
  779.                                                                                                                                                                                                                                                                                                                                 {
  780.                                                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  781.                                                                                                                                                                                                                                                                                                                                     this.bunny = true;
  782.                                                                                                                                                                                                                                                                                                                                     bool flag4 = true;
  783.                                                                                                                                                                                                                                                                                                                                     if (array[111] > 0)
  784.                                                                                                                                                                                                                                                                                                                                     {
  785.                                                                                                                                                                                                                                                                                                                                         flag4 = false;
  786.                                                                                                                                                                                                                                                                                                                                     }
  787.                                                                                                                                                                                                                                                                                                                                     if (flag4)
  788.                                                                                                                                                                                                                                                                                                                                     {
  789.                                                                                                                                                                                                                                                                                                                                         Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 111, 0, 0f, this.whoAmi, 0f, 0f);
  790.                                                                                                                                                                                                                                                                                                                                     }
  791.                                                                                                                                                                                                                                                                                                                                 }
  792.                                                                                                                                                                                                                                                                                                                                 else
  793.                                                                                                                                                                                                                                                                                                                                 {
  794.                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 41)
  795.                                                                                                                                                                                                                                                                                                                                     {
  796.                                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  797.                                                                                                                                                                                                                                                                                                                                         this.penguin = true;
  798.                                                                                                                                                                                                                                                                                                                                         bool flag5 = true;
  799.                                                                                                                                                                                                                                                                                                                                         if (array[112] > 0)
  800.                                                                                                                                                                                                                                                                                                                                         {
  801.                                                                                                                                                                                                                                                                                                                                             flag5 = false;
  802.                                                                                                                                                                                                                                                                                                                                         }
  803.                                                                                                                                                                                                                                                                                                                                         if (flag5)
  804.                                                                                                                                                                                                                                                                                                                                         {
  805.                                                                                                                                                                                                                                                                                                                                             Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 112, 0, 0f, this.whoAmi, 0f, 0f);
  806.                                                                                                                                                                                                                                                                                                                                         }
  807.                                                                                                                                                                                                                                                                                                                                     }
  808.                                                                                                                                                                                                                                                                                                                                     else
  809.                                                                                                                                                                                                                                                                                                                                     {
  810.                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 91)
  811.                                                                                                                                                                                                                                                                                                                                         {
  812.                                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  813.                                                                                                                                                                                                                                                                                                                                             this.puppy = true;
  814.                                                                                                                                                                                                                                                                                                                                             bool flag6 = true;
  815.                                                                                                                                                                                                                                                                                                                                             if (array[334] > 0)
  816.                                                                                                                                                                                                                                                                                                                                             {
  817.                                                                                                                                                                                                                                                                                                                                                 flag6 = false;
  818.                                                                                                                                                                                                                                                                                                                                             }
  819.                                                                                                                                                                                                                                                                                                                                             if (flag6)
  820.                                                                                                                                                                                                                                                                                                                                             {
  821.                                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 334, 0, 0f, this.whoAmi, 0f, 0f);
  822.                                                                                                                                                                                                                                                                                                                                             }
  823.                                                                                                                                                                                                                                                                                                                                         }
  824.                                                                                                                                                                                                                                                                                                                                         else
  825.                                                                                                                                                                                                                                                                                                                                         {
  826.                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 92)
  827.                                                                                                                                                                                                                                                                                                                                             {
  828.                                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  829.                                                                                                                                                                                                                                                                                                                                                 this.grinch = true;
  830.                                                                                                                                                                                                                                                                                                                                                 bool flag7 = true;
  831.                                                                                                                                                                                                                                                                                                                                                 if (array[353] > 0)
  832.                                                                                                                                                                                                                                                                                                                                                 {
  833.                                                                                                                                                                                                                                                                                                                                                     flag7 = false;
  834.                                                                                                                                                                                                                                                                                                                                                 }
  835.                                                                                                                                                                                                                                                                                                                                                 if (flag7)
  836.                                                                                                                                                                                                                                                                                                                                                 {
  837.                                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 353, 0, 0f, this.whoAmi, 0f, 0f);
  838.                                                                                                                                                                                                                                                                                                                                                 }
  839.                                                                                                                                                                                                                                                                                                                                             }
  840.                                                                                                                                                                                                                                                                                                                                             else
  841.                                                                                                                                                                                                                                                                                                                                             {
  842.                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 84)
  843.                                                                                                                                                                                                                                                                                                                                                 {
  844.                                                                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  845.                                                                                                                                                                                                                                                                                                                                                     this.blackCat = true;
  846.                                                                                                                                                                                                                                                                                                                                                     bool flag8 = true;
  847.                                                                                                                                                                                                                                                                                                                                                     if (array[319] > 0)
  848.                                                                                                                                                                                                                                                                                                                                                     {
  849.                                                                                                                                                                                                                                                                                                                                                         flag8 = false;
  850.                                                                                                                                                                                                                                                                                                                                                     }
  851.                                                                                                                                                                                                                                                                                                                                                     if (flag8)
  852.                                                                                                                                                                                                                                                                                                                                                     {
  853.                                                                                                                                                                                                                                                                                                                                                         Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 319, 0, 0f, this.whoAmi, 0f, 0f);
  854.                                                                                                                                                                                                                                                                                                                                                     }
  855.                                                                                                                                                                                                                                                                                                                                                 }
  856.                                                                                                                                                                                                                                                                                                                                                 else
  857.                                                                                                                                                                                                                                                                                                                                                 {
  858.                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 61)
  859.                                                                                                                                                                                                                                                                                                                                                     {
  860.                                                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  861.                                                                                                                                                                                                                                                                                                                                                         this.dino = true;
  862.                                                                                                                                                                                                                                                                                                                                                         bool flag9 = true;
  863.                                                                                                                                                                                                                                                                                                                                                         if (array[236] > 0)
  864.                                                                                                                                                                                                                                                                                                                                                         {
  865.                                                                                                                                                                                                                                                                                                                                                             flag9 = false;
  866.                                                                                                                                                                                                                                                                                                                                                         }
  867.                                                                                                                                                                                                                                                                                                                                                         if (flag9)
  868.                                                                                                                                                                                                                                                                                                                                                         {
  869.                                                                                                                                                                                                                                                                                                                                                             Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 236, 0, 0f, this.whoAmi, 0f, 0f);
  870.                                                                                                                                                                                                                                                                                                                                                         }
  871.                                                                                                                                                                                                                                                                                                                                                     }
  872.                                                                                                                                                                                                                                                                                                                                                     else
  873.                                                                                                                                                                                                                                                                                                                                                     {
  874.                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 65)
  875.                                                                                                                                                                                                                                                                                                                                                         {
  876.                                                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  877.                                                                                                                                                                                                                                                                                                                                                             this.eyeSpring = true;
  878.                                                                                                                                                                                                                                                                                                                                                             bool flag10 = true;
  879.                                                                                                                                                                                                                                                                                                                                                             if (array[268] > 0)
  880.                                                                                                                                                                                                                                                                                                                                                             {
  881.                                                                                                                                                                                                                                                                                                                                                                 flag10 = false;
  882.                                                                                                                                                                                                                                                                                                                                                             }
  883.                                                                                                                                                                                                                                                                                                                                                             if (flag10)
  884.                                                                                                                                                                                                                                                                                                                                                             {
  885.                                                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 268, 0, 0f, this.whoAmi, 0f, 0f);
  886.                                                                                                                                                                                                                                                                                                                                                             }
  887.                                                                                                                                                                                                                                                                                                                                                         }
  888.                                                                                                                                                                                                                                                                                                                                                         else
  889.                                                                                                                                                                                                                                                                                                                                                         {
  890.                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 66)
  891.                                                                                                                                                                                                                                                                                                                                                             {
  892.                                                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  893.                                                                                                                                                                                                                                                                                                                                                                 this.snowman = true;
  894.                                                                                                                                                                                                                                                                                                                                                                 bool flag11 = true;
  895.                                                                                                                                                                                                                                                                                                                                                                 if (array[269] > 0)
  896.                                                                                                                                                                                                                                                                                                                                                                 {
  897.                                                                                                                                                                                                                                                                                                                                                                     flag11 = false;
  898.                                                                                                                                                                                                                                                                                                                                                                 }
  899.                                                                                                                                                                                                                                                                                                                                                                 if (flag11)
  900.                                                                                                                                                                                                                                                                                                                                                                 {
  901.                                                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 269, 0, 0f, this.whoAmi, 0f, 0f);
  902.                                                                                                                                                                                                                                                                                                                                                                 }
  903.                                                                                                                                                                                                                                                                                                                                                             }
  904.                                                                                                                                                                                                                                                                                                                                                             else
  905.                                                                                                                                                                                                                                                                                                                                                             {
  906.                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 42)
  907.                                                                                                                                                                                                                                                                                                                                                                 {
  908.                                                                                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  909.                                                                                                                                                                                                                                                                                                                                                                     this.turtle = true;
  910.                                                                                                                                                                                                                                                                                                                                                                     bool flag12 = true;
  911.                                                                                                                                                                                                                                                                                                                                                                     if (array[127] > 0)
  912.                                                                                                                                                                                                                                                                                                                                                                     {
  913.                                                                                                                                                                                                                                                                                                                                                                         flag12 = false;
  914.                                                                                                                                                                                                                                                                                                                                                                     }
  915.                                                                                                                                                                                                                                                                                                                                                                     if (flag12)
  916.                                                                                                                                                                                                                                                                                                                                                                     {
  917.                                                                                                                                                                                                                                                                                                                                                                         Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 127, 0, 0f, this.whoAmi, 0f, 0f);
  918.                                                                                                                                                                                                                                                                                                                                                                     }
  919.                                                                                                                                                                                                                                                                                                                                                                 }
  920.                                                                                                                                                                                                                                                                                                                                                                 else
  921.                                                                                                                                                                                                                                                                                                                                                                 {
  922.                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 45)
  923.                                                                                                                                                                                                                                                                                                                                                                     {
  924.                                                                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  925.                                                                                                                                                                                                                                                                                                                                                                         this.eater = true;
  926.                                                                                                                                                                                                                                                                                                                                                                         bool flag13 = true;
  927.                                                                                                                                                                                                                                                                                                                                                                         if (array[175] > 0)
  928.                                                                                                                                                                                                                                                                                                                                                                         {
  929.                                                                                                                                                                                                                                                                                                                                                                             flag13 = false;
  930.                                                                                                                                                                                                                                                                                                                                                                         }
  931.                                                                                                                                                                                                                                                                                                                                                                         if (flag13)
  932.                                                                                                                                                                                                                                                                                                                                                                         {
  933.                                                                                                                                                                                                                                                                                                                                                                             Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 175, 0, 0f, this.whoAmi, 0f, 0f);
  934.                                                                                                                                                                                                                                                                                                                                                                         }
  935.                                                                                                                                                                                                                                                                                                                                                                     }
  936.                                                                                                                                                                                                                                                                                                                                                                     else
  937.                                                                                                                                                                                                                                                                                                                                                                     {
  938.                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 50)
  939.                                                                                                                                                                                                                                                                                                                                                                         {
  940.                                                                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  941.                                                                                                                                                                                                                                                                                                                                                                             this.skeletron = true;
  942.                                                                                                                                                                                                                                                                                                                                                                             bool flag14 = true;
  943.                                                                                                                                                                                                                                                                                                                                                                             if (array[197] > 0)
  944.                                                                                                                                                                                                                                                                                                                                                                             {
  945.                                                                                                                                                                                                                                                                                                                                                                                 flag14 = false;
  946.                                                                                                                                                                                                                                                                                                                                                                             }
  947.                                                                                                                                                                                                                                                                                                                                                                             if (flag14)
  948.                                                                                                                                                                                                                                                                                                                                                                             {
  949.                                                                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 197, 0, 0f, this.whoAmi, 0f, 0f);
  950.                                                                                                                                                                                                                                                                                                                                                                             }
  951.                                                                                                                                                                                                                                                                                                                                                                         }
  952.                                                                                                                                                                                                                                                                                                                                                                         else
  953.                                                                                                                                                                                                                                                                                                                                                                         {
  954.                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 51)
  955.                                                                                                                                                                                                                                                                                                                                                                             {
  956.                                                                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  957.                                                                                                                                                                                                                                                                                                                                                                                 this.hornet = true;
  958.                                                                                                                                                                                                                                                                                                                                                                                 bool flag15 = true;
  959.                                                                                                                                                                                                                                                                                                                                                                                 if (array[198] > 0)
  960.                                                                                                                                                                                                                                                                                                                                                                                 {
  961.                                                                                                                                                                                                                                                                                                                                                                                     flag15 = false;
  962.                                                                                                                                                                                                                                                                                                                                                                                 }
  963.                                                                                                                                                                                                                                                                                                                                                                                 if (flag15)
  964.                                                                                                                                                                                                                                                                                                                                                                                 {
  965.                                                                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 198, 0, 0f, this.whoAmi, 0f, 0f);
  966.                                                                                                                                                                                                                                                                                                                                                                                 }
  967.                                                                                                                                                                                                                                                                                                                                                                             }
  968.                                                                                                                                                                                                                                                                                                                                                                             else
  969.                                                                                                                                                                                                                                                                                                                                                                             {
  970.                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 52)
  971.                                                                                                                                                                                                                                                                                                                                                                                 {
  972.                                                                                                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  973.                                                                                                                                                                                                                                                                                                                                                                                     this.tiki = true;
  974.                                                                                                                                                                                                                                                                                                                                                                                     bool flag16 = true;
  975.                                                                                                                                                                                                                                                                                                                                                                                     if (array[199] > 0)
  976.                                                                                                                                                                                                                                                                                                                                                                                     {
  977.                                                                                                                                                                                                                                                                                                                                                                                         flag16 = false;
  978.                                                                                                                                                                                                                                                                                                                                                                                     }
  979.                                                                                                                                                                                                                                                                                                                                                                                     if (flag16)
  980.                                                                                                                                                                                                                                                                                                                                                                                     {
  981.                                                                                                                                                                                                                                                                                                                                                                                         Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 199, 0, 0f, this.whoAmi, 0f, 0f);
  982.                                                                                                                                                                                                                                                                                                                                                                                     }
  983.                                                                                                                                                                                                                                                                                                                                                                                 }
  984.                                                                                                                                                                                                                                                                                                                                                                                 else
  985.                                                                                                                                                                                                                                                                                                                                                                                 {
  986.                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 53)
  987.                                                                                                                                                                                                                                                                                                                                                                                     {
  988.                                                                                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  989.                                                                                                                                                                                                                                                                                                                                                                                         this.lizard = true;
  990.                                                                                                                                                                                                                                                                                                                                                                                         bool flag17 = true;
  991.                                                                                                                                                                                                                                                                                                                                                                                         if (array[200] > 0)
  992.                                                                                                                                                                                                                                                                                                                                                                                         {
  993.                                                                                                                                                                                                                                                                                                                                                                                             flag17 = false;
  994.                                                                                                                                                                                                                                                                                                                                                                                         }
  995.                                                                                                                                                                                                                                                                                                                                                                                         if (flag17)
  996.                                                                                                                                                                                                                                                                                                                                                                                         {
  997.                                                                                                                                                                                                                                                                                                                                                                                             Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 200, 0, 0f, this.whoAmi, 0f, 0f);
  998.                                                                                                                                                                                                                                                                                                                                                                                         }
  999.                                                                                                                                                                                                                                                                                                                                                                                     }
  1000.                                                                                                                                                                                                                                                                                                                                                                                     else
  1001.                                                                                                                                                                                                                                                                                                                                                                                     {
  1002.                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 54)
  1003.                                                                                                                                                                                                                                                                                                                                                                                         {
  1004.                                                                                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  1005.                                                                                                                                                                                                                                                                                                                                                                                             this.parrot = true;
  1006.                                                                                                                                                                                                                                                                                                                                                                                             bool flag18 = true;
  1007.                                                                                                                                                                                                                                                                                                                                                                                             if (array[208] > 0)
  1008.                                                                                                                                                                                                                                                                                                                                                                                             {
  1009.                                                                                                                                                                                                                                                                                                                                                                                                 flag18 = false;
  1010.                                                                                                                                                                                                                                                                                                                                                                                             }
  1011.                                                                                                                                                                                                                                                                                                                                                                                             if (flag18)
  1012.                                                                                                                                                                                                                                                                                                                                                                                             {
  1013.                                                                                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 208, 0, 0f, this.whoAmi, 0f, 0f);
  1014.                                                                                                                                                                                                                                                                                                                                                                                             }
  1015.                                                                                                                                                                                                                                                                                                                                                                                         }
  1016.                                                                                                                                                                                                                                                                                                                                                                                         else
  1017.                                                                                                                                                                                                                                                                                                                                                                                         {
  1018.                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 55)
  1019.                                                                                                                                                                                                                                                                                                                                                                                             {
  1020.                                                                                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  1021.                                                                                                                                                                                                                                                                                                                                                                                                 this.truffle = true;
  1022.                                                                                                                                                                                                                                                                                                                                                                                                 bool flag19 = true;
  1023.                                                                                                                                                                                                                                                                                                                                                                                                 if (array[209] > 0)
  1024.                                                                                                                                                                                                                                                                                                                                                                                                 {
  1025.                                                                                                                                                                                                                                                                                                                                                                                                     flag19 = false;
  1026.                                                                                                                                                                                                                                                                                                                                                                                                 }
  1027.                                                                                                                                                                                                                                                                                                                                                                                                 if (flag19)
  1028.                                                                                                                                                                                                                                                                                                                                                                                                 {
  1029.                                                                                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 209, 0, 0f, this.whoAmi, 0f, 0f);
  1030.                                                                                                                                                                                                                                                                                                                                                                                                 }
  1031.                                                                                                                                                                                                                                                                                                                                                                                             }
  1032.                                                                                                                                                                                                                                                                                                                                                                                             else
  1033.                                                                                                                                                                                                                                                                                                                                                                                             {
  1034.                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 56)
  1035.                                                                                                                                                                                                                                                                                                                                                                                                 {
  1036.                                                                                                                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  1037.                                                                                                                                                                                                                                                                                                                                                                                                     this.sapling = true;
  1038.                                                                                                                                                                                                                                                                                                                                                                                                     bool flag20 = true;
  1039.                                                                                                                                                                                                                                                                                                                                                                                                     if (array[210] > 0)
  1040.                                                                                                                                                                                                                                                                                                                                                                                                     {
  1041.                                                                                                                                                                                                                                                                                                                                                                                                         flag20 = false;
  1042.                                                                                                                                                                                                                                                                                                                                                                                                     }
  1043.                                                                                                                                                                                                                                                                                                                                                                                                     if (flag20)
  1044.                                                                                                                                                                                                                                                                                                                                                                                                     {
  1045.                                                                                                                                                                                                                                                                                                                                                                                                         Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 210, 0, 0f, this.whoAmi, 0f, 0f);
  1046.                                                                                                                                                                                                                                                                                                                                                                                                     }
  1047.                                                                                                                                                                                                                                                                                                                                                                                                 }
  1048.                                                                                                                                                                                                                                                                                                                                                                                                 else
  1049.                                                                                                                                                                                                                                                                                                                                                                                                 {
  1050.                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 85)
  1051.                                                                                                                                                                                                                                                                                                                                                                                                     {
  1052.                                                                                                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  1053.                                                                                                                                                                                                                                                                                                                                                                                                         this.cSapling = true;
  1054.                                                                                                                                                                                                                                                                                                                                                                                                         bool flag21 = true;
  1055.                                                                                                                                                                                                                                                                                                                                                                                                         if (array[324] > 0)
  1056.                                                                                                                                                                                                                                                                                                                                                                                                         {
  1057.                                                                                                                                                                                                                                                                                                                                                                                                             flag21 = false;
  1058.                                                                                                                                                                                                                                                                                                                                                                                                         }
  1059.                                                                                                                                                                                                                                                                                                                                                                                                         if (flag21)
  1060.                                                                                                                                                                                                                                                                                                                                                                                                         {
  1061.                                                                                                                                                                                                                                                                                                                                                                                                             Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 324, 0, 0f, this.whoAmi, 0f, 0f);
  1062.                                                                                                                                                                                                                                                                                                                                                                                                         }
  1063.                                                                                                                                                                                                                                                                                                                                                                                                     }
  1064.                                                                                                                                                                                                                                                                                                                                                                                                     else
  1065.                                                                                                                                                                                                                                                                                                                                                                                                     {
  1066.                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 81)
  1067.                                                                                                                                                                                                                                                                                                                                                                                                         {
  1068.                                                                                                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  1069.                                                                                                                                                                                                                                                                                                                                                                                                             this.spider = true;
  1070.                                                                                                                                                                                                                                                                                                                                                                                                             bool flag22 = true;
  1071.                                                                                                                                                                                                                                                                                                                                                                                                             if (array[313] > 0)
  1072.                                                                                                                                                                                                                                                                                                                                                                                                             {
  1073.                                                                                                                                                                                                                                                                                                                                                                                                                 flag22 = false;
  1074.                                                                                                                                                                                                                                                                                                                                                                                                             }
  1075.                                                                                                                                                                                                                                                                                                                                                                                                             if (flag22)
  1076.                                                                                                                                                                                                                                                                                                                                                                                                             {
  1077.                                                                                                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 313, 0, 0f, this.whoAmi, 0f, 0f);
  1078.                                                                                                                                                                                                                                                                                                                                                                                                             }
  1079.                                                                                                                                                                                                                                                                                                                                                                                                         }
  1080.                                                                                                                                                                                                                                                                                                                                                                                                         else
  1081.                                                                                                                                                                                                                                                                                                                                                                                                         {
  1082.                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 82)
  1083.                                                                                                                                                                                                                                                                                                                                                                                                             {
  1084.                                                                                                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  1085.                                                                                                                                                                                                                                                                                                                                                                                                                 this.squashling = true;
  1086.                                                                                                                                                                                                                                                                                                                                                                                                                 bool flag23 = true;
  1087.                                                                                                                                                                                                                                                                                                                                                                                                                 if (array[314] > 0)
  1088.                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1089.                                                                                                                                                                                                                                                                                                                                                                                                                     flag23 = false;
  1090.                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1091.                                                                                                                                                                                                                                                                                                                                                                                                                 if (flag23)
  1092.                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1093.                                                                                                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 314, 0, 0f, this.whoAmi, 0f, 0f);
  1094.                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1095.                                                                                                                                                                                                                                                                                                                                                                                                             }
  1096.                                                                                                                                                                                                                                                                                                                                                                                                             else
  1097.                                                                                                                                                                                                                                                                                                                                                                                                             {
  1098.                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 57)
  1099.                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1100.                                                                                                                                                                                                                                                                                                                                                                                                                     this.buffTime[k] = 18000;
  1101.                                                                                                                                                                                                                                                                                                                                                                                                                     this.wisp = true;
  1102.                                                                                                                                                                                                                                                                                                                                                                                                                     bool flag24 = true;
  1103.                                                                                                                                                                                                                                                                                                                                                                                                                     if (array[211] > 0)
  1104.                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1105.                                                                                                                                                                                                                                                                                                                                                                                                                         flag24 = false;
  1106.                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1107.                                                                                                                                                                                                                                                                                                                                                                                                                     if (flag24)
  1108.                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1109.                                                                                                                                                                                                                                                                                                                                                                                                                         Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 211, 0, 0f, this.whoAmi, 0f, 0f);
  1110.                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1111.                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1112.                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1113.                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1114.                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 60)
  1115.                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1116.                                                                                                                                                                                                                                                                                                                                                                                                                         this.buffTime[k] = 18000;
  1117.                                                                                                                                                                                                                                                                                                                                                                                                                         this.crystalLeaf = true;
  1118.                                                                                                                                                                                                                                                                                                                                                                                                                         bool flag25 = true;
  1119.                                                                                                                                                                                                                                                                                                                                                                                                                         for (int num9 = 0; num9 < 1000; num9++)
  1120.                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1121.                                                                                                                                                                                                                                                                                                                                                                                                                             if (Main.projectile[num9].active && Main.projectile[num9].owner == this.whoAmi && Main.projectile[num9].type == 226)
  1122.                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1123.                                                                                                                                                                                                                                                                                                                                                                                                                                 if (!flag25)
  1124.                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1125.                                                                                                                                                                                                                                                                                                                                                                                                                                     Main.projectile[num9].Kill();
  1126.                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1127.                                                                                                                                                                                                                                                                                                                                                                                                                                 flag25 = false;
  1128.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1129.                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1130.                                                                                                                                                                                                                                                                                                                                                                                                                         if (flag25)
  1131.                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1132.                                                                                                                                                                                                                                                                                                                                                                                                                             Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 226, 0, 0f, this.whoAmi, 0f, 0f);
  1133.                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1134.                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1135.                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1136.                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1137.                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 127)
  1138.                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1139.                                                                                                                                                                                                                                                                                                                                                                                                                             this.buffTime[k] = 18000;
  1140.                                                                                                                                                                                                                                                                                                                                                                                                                             this.zephyrfish = true;
  1141.                                                                                                                                                                                                                                                                                                                                                                                                                             bool flag26 = true;
  1142.                                                                                                                                                                                                                                                                                                                                                                                                                             if (array[380] > 0)
  1143.                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1144.                                                                                                                                                                                                                                                                                                                                                                                                                                 flag26 = false;
  1145.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1146.                                                                                                                                                                                                                                                                                                                                                                                                                             if (flag26)
  1147.                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1148.                                                                                                                                                                                                                                                                                                                                                                                                                                 Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 380, 0, 0f, this.whoAmi, 0f, 0f);
  1149.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1150.                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1151.                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1152.                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1153.                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 136)
  1154.                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1155.                                                                                                                                                                                                                                                                                                                                                                                                                                 this.buffTime[k] = 18000;
  1156.                                                                                                                                                                                                                                                                                                                                                                                                                                 this.miniMinotaur = true;
  1157.                                                                                                                                                                                                                                                                                                                                                                                                                                 bool flag27 = true;
  1158.                                                                                                                                                                                                                                                                                                                                                                                                                                 if (array[398] > 0)
  1159.                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1160.                                                                                                                                                                                                                                                                                                                                                                                                                                     flag27 = false;
  1161.                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1162.                                                                                                                                                                                                                                                                                                                                                                                                                                 if (flag27)
  1163.                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1164.                                                                                                                                                                                                                                                                                                                                                                                                                                     Projectile.NewProjectile(this.position.X + (float)(this.width / 2), this.position.Y + (float)(this.height / 2), 0f, 0f, 398, 0, 0f, this.whoAmi, 0f, 0f);
  1165.                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1166.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1167.                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1168.                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1169.                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 70)
  1170.                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1171.                                                                                                                                                                                                                                                                                                                                                                                                                                     this.venom = true;
  1172.                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1173.                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1174.                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1175.                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 20)
  1176.                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1177.                                                                                                                                                                                                                                                                                                                                                                                                                                         this.poisoned = true;
  1178.                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1179.                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1180.                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1181.                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 21)
  1182.                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1183.                                                                                                                                                                                                                                                                                                                                                                                                                                             this.potionDelay = this.buffTime[k];
  1184.                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1185.                                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1186.                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1187.                                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 22)
  1188.                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1189.                                                                                                                                                                                                                                                                                                                                                                                                                                                 this.blind = true;
  1190.                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1191.                                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1192.                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1193.                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 80)
  1194.                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1195.                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.blackout = true;
  1196.                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1197.                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1198.                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1199.                                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 23)
  1200.                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1201.                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.noItems = true;
  1202.                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1203.                                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1204.                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1205.                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 24)
  1206.                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1207.                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.onFire = true;
  1208.                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1209.                                                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1210.                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1211.                                                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 103)
  1212.                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1213.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 this.dripping = true;
  1214.                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1215.                                                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1216.                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1217.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 137)
  1218.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1219.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.drippingSlime = true;
  1220.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1221.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1222.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1223.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 67)
  1224.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1225.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.burned = true;
  1226.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1227.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1228.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1229.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 68)
  1230.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1231.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.suffocating = true;
  1232.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1233.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1234.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1235.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 39)
  1236.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1237.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 this.onFire2 = true;
  1238.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1239.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1240.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1241.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 44)
  1242.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1243.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.onFrostBurn = true;
  1244.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1245.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1246.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1247.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 43)
  1248.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1249.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.paladinBuff = true;
  1250.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1251.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1252.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1253.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 29)
  1254.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1255.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.magicCrit += 2;
  1256.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.magicDamage += 0.05f;
  1257.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.statManaMax2 += 20;
  1258.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.manaCost -= 0.02f;
  1259.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1260.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1261.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1262.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 28)
  1263.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1264.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (!Main.dayTime && this.wolfAcc && !this.merman)
  1265.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1266.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.lifeRegen++;
  1267.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.wereWolf = true;
  1268.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeCrit += 2;
  1269.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeDamage += 0.051f;
  1270.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeSpeed += 0.051f;
  1271.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.statDefense += 3;
  1272.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.moveSpeed += 0.05f;
  1273.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1274.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1275.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1276.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.DelBuff(k);
  1277.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1278.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1279.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1280.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1281.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 33)
  1282.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1283.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeDamage -= 0.051f;
  1284.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeSpeed -= 0.051f;
  1285.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.statDefense -= 4;
  1286.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.moveSpeed -= 0.1f;
  1287.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1288.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1289.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1290.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 25)
  1291.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1292.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.statDefense -= 4;
  1293.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.meleeCrit += 2;
  1294.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.meleeDamage += 0.1f;
  1295.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.meleeSpeed += 0.1f;
  1296.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1297.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1298.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1299.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 26)
  1300.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1301.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.statDefense += 2;
  1302.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.meleeCrit += 2;
  1303.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.meleeDamage += 0.05f;
  1304.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.meleeSpeed += 0.05f;
  1305.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.magicCrit += 2;
  1306.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.magicDamage += 0.05f;
  1307.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.rangedCrit += 2;
  1308.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.rangedDamage += 0.05f;
  1309.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.minionDamage += 0.05f;
  1310.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.minionKB += 0.5f;
  1311.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.moveSpeed += 0.2f;
  1312.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1313.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1314.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1315.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 71)
  1316.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1317.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 this.meleeEnchant = 1;
  1318.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1319.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1320.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1321.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 73)
  1322.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1323.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeEnchant = 2;
  1324.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1325.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1326.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1327.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 74)
  1328.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1329.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.meleeEnchant = 3;
  1330.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1331.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1332.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1333.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 75)
  1334.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1335.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.meleeEnchant = 4;
  1336.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1337.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         else
  1338.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1339.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             if (this.buffType[k] == 76)
  1340.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1341.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 this.meleeEnchant = 5;
  1342.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1343.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             else
  1344.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             {
  1345.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (this.buffType[k] == 77)
  1346.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1347.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     this.meleeEnchant = 6;
  1348.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1349.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else
  1350.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
  1351.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     if (this.buffType[k] == 78)
  1352.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1353.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         this.meleeEnchant = 7;
  1354.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1355.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     else
  1356.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     {
  1357.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (this.buffType[k] == 79)
  1358.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         {
  1359.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             this.meleeEnchant = 8;
  1360.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1361.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1362.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1363.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1364.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1365.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1366.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1367.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1368.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1369.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1370.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1371.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1372.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1373.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1374.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1375.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1376.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1377.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1378.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1379.                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1380.                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1381.                                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1382.                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1383.                                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1384.                                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1385.                                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1386.                                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1387.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  1388.                                                                                                                                                                                                                                                                                                                                                                                                                         }
  1389.                                                                                                                                                                                                                                                                                                                                                                                                                     }
  1390.                                                                                                                                                                                                                                                                                                                                                                                                                 }
  1391.                                                                                                                                                                                                                                                                                                                                                                                                             }
  1392.                                                                                                                                                                                                                                                                                                                                                                                                         }
  1393.                                                                                                                                                                                                                                                                                                                                                                                                     }
  1394.                                                                                                                                                                                                                                                                                                                                                                                                 }
  1395.                                                                                                                                                                                                                                                                                                                                                                                             }
  1396.                                                                                                                                                                                                                                                                                                                                                                                         }
  1397.                                                                                                                                                                                                                                                                                                                                                                                     }
  1398.                                                                                                                                                                                                                                                                                                                                                                                 }
  1399.                                                                                                                                                                                                                                                                                                                                                                             }
  1400.                                                                                                                                                                                                                                                                                                                                                                         }
  1401.                                                                                                                                                                                                                                                                                                                                                                     }
  1402.                                                                                                                                                                                                                                                                                                                                                                 }
  1403.                                                                                                                                                                                                                                                                                                                                                             }
  1404.                                                                                                                                                                                                                                                                                                                                                         }
  1405.                                                                                                                                                                                                                                                                                                                                                     }
  1406.                                                                                                                                                                                                                                                                                                                                                 }
  1407.                                                                                                                                                                                                                                                                                                                                             }
  1408.                                                                                                                                                                                                                                                                                                                                         }
  1409.                                                                                                                                                                                                                                                                                                                                     }
  1410.                                                                                                                                                                                                                                                                                                                                 }
  1411.                                                                                                                                                                                                                                                                                                                             }
  1412.                                                                                                                                                                                                                                                                                                                         }
  1413.                                                                                                                                                                                                                                                                                                                     }
  1414.                                                                                                                                                                                                                                                                                                                 }
  1415.                                                                                                                                                                                                                                                                                                             }
  1416.                                                                                                                                                                                                                                                                                                         }
  1417.                                                                                                                                                                                                                                                                                                     }
  1418.                                                                                                                                                                                                                                                                                                 }
  1419.                                                                                                                                                                                                                                                                                             }
  1420.                                                                                                                                                                                                                                                                                         }
  1421.                                                                                                                                                                                                                                                                                     }
  1422.                                                                                                                                                                                                                                                                                 }
  1423.                                                                                                                                                                                                                                                                             }
  1424.                                                                                                                                                                                                                                                                         }
  1425.                                                                                                                                                                                                                                                                     }
  1426.                                                                                                                                                                                                                                                                 }
  1427.                                                                                                                                                                                                                                                             }
  1428.                                                                                                                                                                                                                                                         }
  1429.                                                                                                                                                                                                                                                     }
  1430.                                                                                                                                                                                                                                                 }
  1431.                                                                                                                                                                                                                                             }
  1432.                                                                                                                                                                                                                                         }
  1433.                                                                                                                                                                                                                                     }
  1434.                                                                                                                                                                                                                                 }
  1435.                                                                                                                                                                                                                             }
  1436.                                                                                                                                                                                                                         }
  1437.                                                                                                                                                                                                                     }
  1438.                                                                                                                                                                                                                 }
  1439.                                                                                                                                                                                                             }
  1440.                                                                                                                                                                                                         }
  1441.                                                                                                                                                                                                     }
  1442.                                                                                                                                                                                                 }
  1443.                                                                                                                                                                                             }
  1444.                                                                                                                                                                                         }
  1445.                                                                                                                                                                                     }
  1446.                                                                                                                                                                                 }
  1447.                                                                                                                                                                             }
  1448.                                                                                                                                                                         }
  1449.                                                                                                                                                                     }
  1450.                                                                                                                                                                 }
  1451.                                                                                                                                                             }
  1452.                                                                                                                                                         }
  1453.                                                                                                                                                     }
  1454.                                                                                                                                                 }
  1455.                                                                                                                                             }
  1456.                                                                                                                                         }
  1457.                                                                                                                                     }
  1458.                                                                                                                                 }
  1459.                                                                                                                             }
  1460.                                                                                                                         }
  1461.                                                                                                                     }
  1462.                                                                                                                 }
  1463.                                                                                                             }
  1464.                                                                                                         }
  1465.                                                                                                     }
  1466.                                                                                                 }
  1467.                                                                                             }
  1468.                                                                                         }
  1469.                                                                                     }
  1470.                                                                                 }
  1471.                                                                             }
  1472.                                                                         }
  1473.                                                                     }
  1474.                                                                 }
  1475.                                                             }
  1476.                                                         }
  1477.                                                     }
  1478.                                                 }
  1479.                                             }
  1480.                                         }
  1481.                                     }
  1482.                                 }
  1483.                             }
  1484.                         }
  1485.                     }
  1486.                 }
  1487.             }
  1488.         }
  1489.     }
  1490. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement