HitEffect()

void Terraria.NPC.HitEffect ( int hitDirection = 0, double dmg = 10::0 )

inline

Definition at line 78386 of file NPC.cs.

    {
        //IL_24fe: Unknown result type (might be due to invalid IL or missing references)
        //IL_251d: Unknown result type (might be due to invalid IL or missing references)
        //IL_26fd: Unknown result type (might be due to invalid IL or missing references)
        if (!active)
        {
            return;
        }
        if (townNPC && life <= 0 && UsesPartyHat())
        {
            bool isShimmerVariant = IsShimmerVariant;
            bool flag = true;
            switch (type)
            {
            case 38:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1298 : 927);
                break;
            case 207:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1305 : 928);
                break;
            case 17:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1321 : 929);
                break;
            case 18:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1325 : 930);
                break;
            case 227:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1331 : 931);
                break;
            case 229:
                if (!IsShimmerVariant)
                {
                    Gore.NewGore(position, velocity, 932);
                }
                break;
            case 142:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1339 : 933);
                break;
            case 453:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1343 : 934);
                break;
            case 178:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1348 : 935);
                break;
            case 353:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1351 : 936);
                break;
            case 368:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1363 : 937);
                break;
            case 108:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1373 : 938);
                break;
            case 588:
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1311 : 1112);
                break;
            default:
                flag = false;
                break;
            }
            if (flag)
            {
                int num = 926;
                switch (GetPartyHatColor())
                {
                case PartyHatColor.Cyan:
                    num = 940;
                    break;
                case PartyHatColor.Pink:
                    num = 939;
                    break;
                case PartyHatColor.Purple:
                    num = 941;
                    break;
                case PartyHatColor.White:
                    num = 942;
                    break;
                }
                Gore.NewGore(position, velocity, num);
            }
        }
        if (daybreak && life <= 0)
        {
            Rectangle hitbox = base.Hitbox;
            for (int i = 0; i < 20; i++)
            {
                int num2 = Utils.SelectRandom<int>(Main.rand, 6, 259, 158);
                int num3 = Dust.NewDust(hitbox.TopLeft(), width, height, num2, 0f, -2.5f);
                Main.dust[num3].alpha = 200;
                Dust dust = Main.dust[num3];
                dust.velocity *= 1.4f;
                dust = Main.dust[num3];
                dust.scale += Main.rand.NextFloat();
            }
            if (Main.netMode != 1)
            {
                for (int j = 0; j < 200; j++)
                {
                    NPC nPC = Main.npc[j];
                    if (nPC.active && !nPC.buffImmune[189] && Distance(nPC.Center) < 100f && !nPC.dontTakeDamage && nPC.lifeMax > 5 && !nPC.friendly && !nPC.townNPC)
                    {
                        nPC.AddBuff(189, 300);
                    }
                }
            }
        }
        if (type == 686 && life <= 0)
        {
            short num4 = 1143;
            Vector2 vector = base.Bottom + (-Vector2.UnitY * 50f).RotatedBy(rotation);
            for (int k = 0; k < 3; k++)
            {
                Vector2 vector2 = vector + Main.rand.NextVector2Circular(15f, 15f);
                Gore gore = Gore.NewGorePerfect(vector2, Main.rand.NextVector2Circular(2f, 2f), num4 + Main.rand.Next(3));
                gore.velocity.Y -= Main.rand.NextFloat();
                Gore gore2 = gore;
                gore2.velocity *= 4f;
            }
            for (int l = 0; l < 1; l++)
            {
                Vector2 vector3 = base.Bottom + (-Vector2.UnitY * 50f).RotatedBy(rotation) + Main.rand.NextVector2Circular(5f, 5f);
                Gore gore3 = Gore.NewGorePerfect(vector3, Main.rand.NextVector2Circular(2f, 2f), 1146);
                gore3.velocity.Y -= Main.rand.NextFloat();
                Gore gore2 = gore3;
                gore2.velocity *= 4f;
            }
            if (Main.netMode != 1)
            {
                Vector2 vector4 = base.Bottom + new Vector2(0f, 48f);
                Vector2 vector5 = velocity;
                Transform(680);
                position = vector4;
                velocity = vector5;
                netUpdate = true;
                if (!unlockedSlimePurpleSpawn)
                {
                    unlockedSlimePurpleSpawn = true;
                    if (Main.netMode == 2)
                    {
                        NetMessage.SendData(7);
                    }
                }
            }
        }
        if (type == 594 && life <= 0)
        {
            int num5 = 1125;
            num5 += (int)(ai[2] - 1f) * 3;
            Vector2 vector6 = base.Bottom + (-Vector2.UnitY * 50f).RotatedBy(rotation);
            for (int m = 0; m < 3; m++)
            {
                Vector2 vector7 = vector6 + Main.rand.NextVector2Circular(15f, 15f);
                Gore gore4 = Gore.NewGorePerfect(vector7, Main.rand.NextVector2Circular(2f, 2f), num5 + Main.rand.Next(3));
                gore4.velocity.Y -= Main.rand.NextFloat();
                Gore gore2 = gore4;
                gore2.velocity *= 4f;
            }
            for (int n = 0; n < 1; n++)
            {
                Vector2 vector8 = base.Bottom + (-Vector2.UnitY * 50f).RotatedBy(rotation) + Main.rand.NextVector2Circular(5f, 5f);
                Gore gore5 = Gore.NewGorePerfect(vector8, Main.rand.NextVector2Circular(2f, 2f), 1146);
                gore5.velocity.Y -= Main.rand.NextFloat();
                Gore gore2 = gore5;
                gore2.velocity *= 4f;
            }
            NPC nPC2 = AI_113_WindyBalloon_GetSlaveNPC();
            if (nPC2 != null)
            {
                nPC2.ai[0] = 0f;
                nPC2.position.Y -= 10f;
                nPC2.netUpdate = true;
            }
        }
        if (type == 661)
        {
            if (life > 0)
            {
                for (int num6 = 0; (double)num6 < dmg / (double)lifeMax * 100.0; num6++)
                {
                    if (Main.rand.Next(5) == 0)
                    {
                        int num7 = 1;
                        Color newColor = Main.hslToRgb((float)num6 / 100f % 1f, 1f, 0.5f) * 0.5f;
                        int num8 = Dust.NewDust(position, width, height, 267, 0f, 0f, 0, newColor);
                        Main.dust[num8].position = base.Center + Main.rand.NextVector2Circular(width, height);
                        Main.dust[num8].velocity = Main.dust[num8].position - base.Center;
                        Main.dust[num8].noGravity = true;
                        Main.dust[num8].fadeIn = 0.6f + Main.rand.NextFloat() * 0.7f * (float)num7;
                        Main.dust[num8].scale = 0.35f;
                        if (num8 != 6000)
                        {
                            Dust dust2 = Dust.CloneDust(num8);
                            Dust dust = dust2;
                            dust.scale /= 2f;
                            dust = dust2;
                            dust.fadeIn *= 0.85f;
                            dust2.color = new Color(255, 255, 255, 255) * 0.5f;
                        }
                    }
                }
            }
            else
            {
                for (int num9 = 0; (float)num9 < 100f; num9++)
                {
                    if (Main.rand.Next(5) == 0)
                    {
                        int num10 = 1;
                        Color newColor2 = Main.hslToRgb((float)num9 / 100f % 1f, 1f, 0.5f) * 0.5f;
                        int num11 = Dust.NewDust(position, width, height, 267, 0f, 0f, 0, newColor2);
                        Main.dust[num11].position = base.Center + Main.rand.NextVector2Circular(width, height);
                        Main.dust[num11].velocity = (Main.dust[num11].position - base.Center) * 0.6f;
                        Main.dust[num11].noGravity = true;
                        Main.dust[num11].fadeIn = 0.7f + Main.rand.NextFloat() * 1.1f * (float)num10;
                        Main.dust[num11].scale = 0.35f;
                        if (num11 != 6000)
                        {
                            Dust dust3 = Dust.CloneDust(num11);
                            Dust dust = dust3;
                            dust.scale /= 2f;
                            dust = dust3;
                            dust.fadeIn *= 0.85f;
                            dust3.color = new Color(255, 255, 255, 255) * 0.5f;
                        }
                    }
                }
            }
        }
        if (type == 521)
        {
            if (life > 0)
            {
                for (int num12 = 0; (double)num12 < dmg / (double)lifeMax * 200.0; num12++)
                {
                    Dust dust4 = Dust.NewDustDirect(position, width, height, 228, 6 * hitDirection, velocity.Y, 0, Color.Transparent, 3f);
                    dust4.noGravity = true;
                    Dust dust = dust4;
                    dust.velocity *= 5f;
                }
            }
            else
            {
                for (int num13 = 0; (float)num13 < 200f; num13++)
                {
                    Dust dust5 = Dust.NewDustDirect(position, width, height, 228, 6 * hitDirection, velocity.Y, 0, Color.Transparent, 3f);
                    dust5.noGravity = true;
                    Dust dust = dust5;
                    dust.velocity *= 5f;
                }
            }
        }
        if (type == 668)
        {
            if (life > 0)
            {
                for (int num14 = 0; (double)num14 < dmg / (double)lifeMax * 100.0; num14++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f, 0, default(Color), 1.2f);
                }
            }
            else
            {
                int num15 = 15;
                Vector2 vector9 = position - new Vector2(num15, num15);
                for (int num16 = 0; num16 < 120; num16++)
                {
                    int num17 = Dust.NewDust(vector9, width + num15 * 2, height + num15 * 2, 5, 0f, 0f, 0, default(Color), 1.5f);
                    Main.dust[num17].velocity = Main.rand.NextVector2Circular(4f, 4f);
                }
                Vector2 vector10 = velocity * 0.6f;
                Gore.NewGore(base.Bottom + new Vector2(-10f, 0f), vector10, 1274, scale);
                Gore.NewGore(base.Bottom + new Vector2(10f, 0f), vector10, 1274, scale);
                Gore.NewGore(base.Center, vector10, 1272, scale);
                Gore.NewGore(base.Center + new Vector2(-10f, 0f), vector10, 1273, scale);
                Gore.NewGore(base.Center + new Vector2(10f, 0f), vector10, 1273, scale);
                Gore.NewGore(base.Top, vector10, 1270, scale);
                Gore.NewGore(base.Top, vector10, 1271, scale);
            }
        }
        if (type == 636)
        {
            if (life > 0)
            {
                for (int num18 = 0; (double)num18 < dmg / (double)lifeMax * 100.0; num18++)
                {
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust.NewDust(position, width, height, 67, hitDirection, -1f);
                    }
                    else
                    {
                        Dust.NewDust(position, width, height, 69, hitDirection, -1f);
                    }
                }
            }
            else
            {
                for (int num19 = 0; num19 < 50; num19++)
                {
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust.NewDust(position, width, height, 67, hitDirection, -1f);
                    }
                    else
                    {
                        Dust.NewDust(position, width, height, 69, 2 * hitDirection, -1f);
                    }
                }
                Vector2 vector11 = velocity * 0.6f;
                Gore.NewGore(position + new Vector2(10f, -20f), vector11, 1262, scale);
                Gore.NewGore(position + new Vector2(10f, 40f), vector11, 1263, scale);
                Gore.NewGore(position + new Vector2(50f, 20f), vector11, 1264, scale);
                Gore.NewGore(position + new Vector2(-10f, -20f), vector11, 1265, scale);
                Gore.NewGore(position, vector11, 1266, scale);
                Gore.NewGore(position + new Vector2(-20f, -20f), vector11, 1267, scale);
                Gore.NewGore(position + new Vector2(-20f, 10f), vector11, 1268, scale);
                Gore.NewGore(position + new Vector2(60f, -20f), vector11, 1267, scale);
                Gore.NewGore(position + new Vector2(60f, 10f), vector11, 1268, scale);
            }
        }
        if (type == 657)
        {
            if (life <= 0)
            {
                Gore.NewGore(position, velocity, 1259, 0.8f);
                Gore.NewGore(position + base.Size * 0.5f, velocity, 1259, 0.8f);
                Gore.NewGore(position, velocity, 1258, scale);
                int num20 = 10;
                for (int num21 = 0; num21 < 150; num21++)
                {
                    Color newColor3 = AI_121_QueenSlime_GetDustColor();
                    newColor3.A = 200;
                    int num22 = Dust.NewDust(position - new Vector2(num20, num20), width + num20 * 2, height + num20 * 2, 4, 8f * Main.rand.NextFloatDirection(), -2f + 6f * Main.rand.NextFloatDirection(), 50, newColor3, 1f + Main.rand.NextFloat() * 0.5f);
                    Dust dust = Main.dust[num22];
                    dust.velocity *= 0.65f;
                    dust = Main.dust[num22];
                    dust.velocity += velocity * 0.5f;
                    if (Main.rand.Next(5) == 0)
                    {
                        Main.dust[num22].noGravity = true;
                        dust = Main.dust[num22];
                        dust.scale *= 1.2f;
                    }
                }
            }
            else
            {
                for (int num23 = 0; num23 < 12; num23++)
                {
                    Color newColor4 = AI_121_QueenSlime_GetDustColor();
                    newColor4.A = 150;
                    int num24 = Dust.NewDust(position, width, height, 4, 2 * hitDirection, -1f, 50, newColor4);
                    Dust dust = Main.dust[num24];
                    dust.velocity *= 0.3f;
                    dust = Main.dust[num24];
                    dust.velocity += velocity * 0.3f;
                    if (Main.rand.Next(3) == 0)
                    {
                        Main.dust[num24].noGravity = true;
                        dust = Main.dust[num24];
                        dust.scale *= 1.2f;
                    }
                }
            }
        }
        if (type >= 658 && type <= 660)
        {
            int num25 = 7;
            float num26 = 1f;
            int num27 = 4;
            Color newColor5 = new Color(78, 136, 255, 150);
            if (type == 659)
            {
                num27 = 243;
                newColor5 = default(Color);
            }
            if (type == 660)
            {
                newColor5 = new Color(150, 100, 200, 150);
            }
            if (life <= 0)
            {
                num26 = 1.5f;
                num25 = 40;
                if (type == 660)
                {
                    Gore.NewGore(position, velocity, 1260, scale);
                    Gore.NewGore(position, velocity, 1260, scale);
                }
            }
            for (int num28 = 0; num28 < num25; num28++)
            {
                int num29 = Dust.NewDust(position, width, height, num27, 2 * hitDirection, -1f, 80, newColor5, num26);
                if (Main.rand.Next(3) != 0)
                {
                    Main.dust[num29].noGravity = true;
                }
            }
        }
        if (type == 667)
        {
            int num30 = 7;
            float num31 = 1.1f;
            int num32 = 10;
            Color newColor6 = default(Color);
            if (life <= 0)
            {
                num31 = 1.5f;
                num30 = 40;
                for (int num33 = 0; num33 < 8; num33++)
                {
                    int num34 = Gore.NewGore(new Vector2(position.X, base.Center.Y - 10f), Vector2.Zero, 1218);
                    Main.gore[num34].velocity = new Vector2((float)Main.rand.Next(1, 10) * 0.3f * 2.5f * (float)hitDirection, 0f - (3f + (float)Main.rand.Next(4) * 0.3f));
                }
            }
            else
            {
                for (int num35 = 0; num35 < 3; num35++)
                {
                    int num36 = Gore.NewGore(new Vector2(position.X, base.Center.Y - 10f), Vector2.Zero, 1218);
                    Main.gore[num36].velocity = new Vector2((float)Main.rand.Next(1, 10) * 0.3f * 2f * (float)hitDirection, 0f - (2.5f + (float)Main.rand.Next(4) * 0.3f));
                }
            }
            for (int num37 = 0; num37 < num30; num37++)
            {
                int num38 = Dust.NewDust(position, width, height, num32, 2 * hitDirection, -1f, 80, newColor6, num31);
                if (Main.rand.Next(3) != 0)
                {
                    Main.dust[num38].noGravity = true;
                }
            }
        }
        if (type == 676)
        {
            int num39 = 8;
            float num40 = 1.1f;
            short num41 = 310;
            if (life <= 0)
            {
                num40 = 1.5f;
                num39 = 40;
            }
            for (int num42 = 0; num42 < num39; num42++)
            {
                Dust dust6 = Main.dust[Dust.NewDust(position, width, height, num41, 2 * hitDirection, -1f, 80, default(Color), num40)];
                if (Main.rand.Next(3) != 0)
                {
                    dust6.noGravity = true;
                }
                Dust dust = dust6;
                dust.velocity *= 1.5f;
                dust = dust6;
                dust.velocity += velocity * 0.1f;
            }
        }
        if (type == 552 || type == 553 || type == 554)
        {
            if (life > 0)
            {
                for (int num43 = 0; (double)num43 < dmg / (double)lifeMax * 20.0; num43++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num44 = 0; (float)num44 < 20f; num44++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                int num45 = 983;
                if (type == 553)
                {
                    num45 = 1067;
                }
                else if (type == 554)
                {
                    num45 = 1071;
                }
                Gore.NewGore(position, velocity, num45, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num45 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num45 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num45 + 1, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num45 + 1, scale);
            }
        }
        else if (type == 561 || type == 562 || type == 563)
        {
            if (life > 0)
            {
                for (int num46 = 0; (double)num46 < dmg / (double)lifeMax * 20.0; num46++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num47 = 0; (float)num47 < 20f; num47++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                int num48 = 987;
                if (type == 562)
                {
                    num48 = 1055;
                }
                else if (type == 563)
                {
                    num48 = 1061;
                }
                Gore.NewGore(position, velocity, num48 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num48, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num48 + 4, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num48 + 5, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num48 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num48 + 1, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num48 + 1, scale);
            }
        }
        else if (type == 555 || type == 556 || type == 557)
        {
            if (life > 0)
            {
                for (int num49 = 0; (double)num49 < dmg / (double)lifeMax * 20.0; num49++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                int num50 = 1031;
                if (type == 556)
                {
                    num50 = 1034;
                }
                if (type == 557)
                {
                    num50 = 1037;
                }
                for (int num51 = 0; (float)num51 < 20f; num51++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, num50, scale);
                Gore.NewGore(new Vector2(position.X + 10f, position.Y + 20f), velocity, num50 + 1, scale);
                Gore.NewGore(new Vector2(position.X + 10f, position.Y + 30f), velocity, num50 + 2, scale);
            }
        }
        else if (type == 551)
        {
            int num52 = (int)((float)life / (float)lifeMax * 100f);
            int num53 = (int)(((double)life + dmg) / (double)(float)lifeMax * 100.0);
            if (num52 != num53 && life > 0 && Main.netMode != 1)
            {
                DD2Event.CheckProgress(type);
            }
            if (life > 0)
            {
                for (int num54 = 0; (double)num54 < dmg / (double)lifeMax * 20.0; num54++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num55 = 0; (float)num55 < 20f; num55++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                if (spriteDirection != -1)
                {
                    Gore.NewGore(position + new Vector2(0f, 54f), velocity, 1079, scale);
                    Gore.NewGore(position + new Vector2(72f, 90f), velocity, 1080, scale);
                    Gore.NewGore(position + new Vector2(102f, 94f), velocity, 1080, scale);
                    Gore.NewGore(position + new Vector2(178f, 0f), velocity, 1081, scale);
                    Gore.NewGore(position + new Vector2(136f, 12f), velocity, 1082, scale);
                    Gore.NewGore(position + new Vector2(82f, 18f), velocity, 1083, scale);
                    Gore.NewGore(position + new Vector2(100f, 26f), velocity, 1084, scale);
                    Gore.NewGore(position + new Vector2(170f, 16f), velocity, 1085, scale);
                    Gore.NewGore(position + new Vector2(190f, 10f), velocity, 1085, scale);
                    Gore.NewGore(position + new Vector2(100f, 36f), velocity, 1086, scale);
                }
                else
                {
                    Gore.NewGore(position + new Vector2(176f, 54f), velocity, 1079, scale);
                    Gore.NewGore(position + new Vector2(158f, 90f), velocity, 1080, scale);
                    Gore.NewGore(position + new Vector2(128f, 94f), velocity, 1080, scale);
                    Gore.NewGore(position + new Vector2(0f, 0f), velocity, 1081, scale);
                    Gore.NewGore(position + new Vector2(60f, 12f), velocity, 1082, scale);
                    Gore.NewGore(position + new Vector2(88f, 18f), velocity, 1083, scale);
                    Gore.NewGore(position + new Vector2(86f, 26f), velocity, 1084, scale);
                    Gore.NewGore(position + new Vector2(40f, 16f), velocity, 1085, scale);
                    Gore.NewGore(position + new Vector2(20f, 10f), velocity, 1085, scale);
                    Gore.NewGore(position + new Vector2(142f, 36f), velocity, 1086, scale);
                }
            }
        }
        else if (type == 572 || type == 573)
        {
            if (life > 0)
            {
                for (int num56 = 0; (double)num56 < dmg / (double)lifeMax * 20.0; num56++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                SoundEngine.GetActiveSound(SlotId.FromFloat(localAI[0]))?.Stop();
                SoundEngine.GetActiveSound(SlotId.FromFloat(localAI[1]))?.Stop();
                for (int num57 = 0; (float)num57 < 20f; num57++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                Vector2 vector12 = base.Center - new Vector2(10f, 10f);
                Gore.NewGore(vector12, velocity, 993, scale);
                Gore.NewGore(new Vector2(vector12.X, vector12.Y + 20f), velocity, 996, scale);
                Gore.NewGore(new Vector2(vector12.X, vector12.Y + 20f), velocity, 995, scale);
                Gore.NewGore(new Vector2(vector12.X, vector12.Y + 34f), velocity, 994, scale);
                Gore.NewGore(new Vector2(vector12.X, vector12.Y + 34f), velocity, 994, scale);
            }
        }
        else if (type == 574 || type == 575)
        {
            if (life > 0)
            {
                for (int num58 = 0; (double)num58 < dmg / (double)lifeMax * 20.0; num58++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                SoundEngine.GetActiveSound(SlotId.FromFloat(localAI[2]))?.Stop();
                for (int num59 = 0; (float)num59 < 20f; num59++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                int num60 = 1050;
                Vector2 vector13 = base.Center - new Vector2(30f, 10f);
                Gore.NewGore(new Vector2(vector13.X, vector13.Y + 10f), velocity, num60, scale);
                Gore.NewGore(new Vector2(vector13.X, vector13.Y + 30f), velocity, num60 + 1, scale);
                Gore.NewGore(new Vector2(vector13.X, vector13.Y + 30f), velocity, num60 + 2, scale);
                Gore.NewGore(new Vector2(vector13.X, vector13.Y + 0f), velocity, num60 + 3, scale);
                Gore.NewGore(new Vector2(vector13.X, vector13.Y + 0f), velocity, num60 + 4, scale);
            }
        }
        else if (type == 570 || type == 571)
        {
            if (life > 0)
            {
                for (int num61 = 0; (double)num61 < dmg / (double)lifeMax * 20.0; num61++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num62 = 0; (float)num62 < 20f; num62++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                int num63 = ((type == 570) ? 1075 : 979);
                Gore.NewGore(position, velocity, num63, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num63 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num63 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num63 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num63 + 1, scale);
            }
        }
        else if (type == 568 || type == 569)
        {
            if (life > 0)
            {
                for (int num64 = 0; (double)num64 < dmg / (double)lifeMax * 20.0; num64++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num65 = 0; (float)num65 < 20f; num65++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                Gore.NewGore(position, velocity, 1020, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1021, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1023, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 1022, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 1022, scale);
            }
        }
        else if (type == 558 || type == 559 || type == 560)
        {
            if (life > 0)
            {
                for (int num66 = 0; (double)num66 < dmg / (double)lifeMax * 20.0; num66++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num67 = 0; (float)num67 < 20f; num67++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                int num68 = 974;
                if (type == 559)
                {
                    num68 = 1040;
                }
                if (type == 560)
                {
                    num68 = 1045;
                }
                Gore.NewGore(position, velocity, num68 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, num68, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, num68, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, num68 + 4, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 24f), velocity, num68 + 1, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 24f), velocity, num68 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 24f), velocity, num68 + 3, scale);
            }
        }
        else if (type == 566 || type == 567)
        {
            if (life > 0)
            {
                for (int num69 = 0; (double)num69 < dmg / (double)lifeMax * 20.0; num69++)
                {
                    Dust.NewDust(position, width, height, 236, hitDirection, -1f);
                }
            }
            else
            {
                for (int num70 = 0; (float)num70 < 20f; num70++)
                {
                    Dust.NewDust(position, width, height, 236, hitDirection, -1f);
                }
                Gore.NewGore(position, velocity, 970, scale);
                if (Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 972, scale);
                }
                if (Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 972, scale);
                }
                if (Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 973, scale);
                }
                if (Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 973, scale);
                }
                if (Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 971, scale);
                }
                if (Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 971, scale);
                }
            }
        }
        else if (type == 576 || type == 577)
        {
            if (life > 0)
            {
                for (int num71 = 0; (double)num71 < dmg / (double)lifeMax * 20.0; num71++)
                {
                    Dust.NewDust(position, width, height, 273, hitDirection, -1f);
                }
            }
            else
            {
                for (int num72 = 0; (float)num72 < 20f; num72++)
                {
                    Dust.NewDust(position, width, height, 273, hitDirection, -1f);
                }
                if (spriteDirection == -1)
                {
                    Gore.NewGore(position + new Vector2(0f, 0f), velocity, 1005 + ((Main.rand.Next(5) == 0) ? 1 : 0), scale);
                    Gore.NewGore(position + new Vector2(18f, 28f), velocity, 1000, scale);
                    int num73 = Gore.NewGore(position + new Vector2(-40f, 70f), velocity, 1001, scale);
                    Main.gore[num73].rotation = (float)Math.PI;
                    num73 = Gore.NewGore(position + new Vector2(4f, 28f), velocity, 1002, scale);
                    Main.gore[num73].rotation = (float)Math.PI;
                    Gore.NewGore(position + new Vector2(36f, 90f), velocity, 1003, scale);
                    Gore.NewGore(position + new Vector2(32f, 90f), velocity, 1004, scale);
                }
                else
                {
                    Gore.NewGore(position + new Vector2(48f, 0f), velocity, 1005 + ((Main.rand.Next(5) == 0) ? 1 : 0), scale);
                    Gore.NewGore(position + new Vector2(22f, 28f), velocity, 1000, scale);
                    Gore.NewGore(position + new Vector2(48f, 70f), velocity, 1001, scale);
                    Gore.NewGore(position + new Vector2(4f, 28f), velocity, 1002, scale);
                    Gore.NewGore(position + new Vector2(36f, 90f), velocity, 1003, scale);
                    Gore.NewGore(position + new Vector2(32f, 90f), velocity, 1004, scale);
                }
            }
        }
        else if (type == 564 || type == 565)
        {
            if (life > 0)
            {
                for (int num74 = 0; (double)num74 < dmg / (double)lifeMax * 20.0; num74++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num75 = 0; (float)num75 < 20f; num75++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                int num76 = 1009;
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, num76, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 15f), velocity, num76 + 1, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 15f), velocity, num76 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 15f), velocity, num76 + 3, scale);
                Gore.NewGore(new Vector2(position.X - 20f, position.Y + 35f), velocity, num76 + 4, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 35f), velocity, num76 + 5, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 35f), velocity, num76 + 6, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 35f), velocity, num76 + 10, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 25f), velocity, num76 + 7, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 25f), velocity, num76 + 8, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 25f), velocity, num76 + 9, scale);
            }
        }
        else if (type == 578)
        {
            if (life > 0)
            {
                for (int num77 = 0; (double)num77 < dmg / (double)lifeMax * 20.0; num77++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num78 = 0; (float)num78 < 20f; num78++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                Gore.NewGore(position, velocity, 999, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 998, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 998, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 997, scale);
            }
        }
        else if (type == 620)
        {
            if (life > 0)
            {
                for (int num79 = 0; (double)num79 < dmg / (double)lifeMax * 150.0; num79++)
                {
                    Dust dust7 = Dust.NewDustDirect(position, width, height, 5, hitDirection, -1f);
                    Dust dust = dust7;
                    dust.velocity *= 2.5f;
                    dust7.scale = 1.7f;
                }
            }
            else
            {
                for (int num80 = 0; (float)num80 < 150f; num80++)
                {
                    Dust dust8 = Dust.NewDustDirect(position, width, height, 5, hitDirection, -1f);
                    Dust dust = dust8;
                    dust.velocity *= 2.5f;
                    dust8.scale = 1.7f;
                }
                int num81 = 1183;
                Gore.NewGore(position, velocity, num81, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num81 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num81 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num81 + 1, scale);
            }
        }
        else if (type == 619)
        {
            if (life > 0)
            {
                for (int num82 = 0; (double)num82 < dmg / (double)lifeMax * 150.0; num82++)
                {
                    Dust dust9 = Dust.NewDustDirect(position, width, height, 5, hitDirection, -1f);
                    Dust dust = dust9;
                    dust.velocity *= 2.5f;
                    dust9.fadeIn = 1.7f;
                }
            }
            else
            {
                for (int num83 = 0; (float)num83 < 150f; num83++)
                {
                    Dust dust10 = Dust.NewDustDirect(position, width, height, 5, hitDirection, -1f);
                    Dust dust = dust10;
                    dust.velocity *= 2.5f;
                    dust10.fadeIn = 1.7f;
                }
                int num84 = 1179;
                Gore.NewGore(position, velocity, num84, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num84 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num84 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num84 + 1, scale);
            }
        }
        else if (type == 618)
        {
            if (life > 0)
            {
                for (int num85 = 0; (double)num85 < dmg / (double)lifeMax * 200.0; num85++)
                {
                    Dust dust11 = Dust.NewDustDirect(position, width, height, 5, hitDirection, -1f);
                    Dust dust = dust11;
                    dust.velocity *= 2.5f;
                    dust11.scale = 2f;
                }
            }
            else
            {
                for (int num86 = 0; (float)num86 < 200f; num86++)
                {
                    Dust dust12 = Dust.NewDustDirect(position, width, height, 5, hitDirection, -1f);
                    Dust dust = dust12;
                    dust.velocity *= 2.5f;
                    dust12.scale = 2.5f;
                }
                int num87 = 1172;
                Gore.NewGore(new Vector2(base.Right.X - 30f, position.Y), velocity, num87, scale);
                Gore.NewGore(position, velocity, num87, scale);
                Gore.NewGore(new Vector2(base.Right.X - 30f, position.Y), velocity, num87 + 1, scale);
                Gore.NewGore(position, velocity, num87 + 1, scale);
                Gore.NewGore(position, velocity, num87 + 2, scale);
                Gore.NewGore(position, velocity, num87 + 3, scale);
                Gore.NewGore(position, velocity, num87 + 4, scale);
                Gore.NewGore(position, velocity, num87 + 4, scale);
                Gore.NewGore(position, velocity, num87 + 5, scale);
                Gore.NewGore(position, velocity, num87 + 5, scale);
                Gore.NewGore(position, velocity, num87 + 6, scale);
                Gore.NewGore(position, velocity, num87 + 6, scale);
            }
        }
        else if (type == 541)
        {
            Color color = new Color(222, 108, 48) * 0.7f;
            if (life > 0)
            {
                for (int num88 = 0; (double)num88 < dmg / (double)lifeMax * 200.0; num88++)
                {
                    Dust dust13 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust13.color = color;
                    dust13.noGravity = true;
                    dust13.scale = 1.5f;
                    dust13.fadeIn = 0.7f;
                    Dust dust = dust13;
                    dust.velocity *= 3f;
                    dust13 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust13.color = color;
                    dust13.noGravity = true;
                    dust13.scale = 1.5f;
                    dust13.fadeIn = 0.7f;
                    dust = dust13;
                    dust.velocity *= 3f;
                }
            }
            else
            {
                for (int num89 = 0; num89 < 30; num89++)
                {
                    Dust dust14 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust14.color = color;
                    dust14.noGravity = true;
                    dust14.scale = 1.5f;
                    dust14.fadeIn = 0.7f;
                    Dust dust = dust14;
                    dust.velocity *= 3f;
                    dust14 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust14.color = color;
                    dust14.noGravity = true;
                    dust14.scale = 1.5f;
                    dust14.fadeIn = 0.7f;
                    dust = dust14;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(position, velocity, 960, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 961, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 963, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 40f), velocity, 962, scale);
            }
        }
        else if (type == 546)
        {
            Color color2 = new Color(150, 108, 78) * 0.7f;
            if (life > 0)
            {
                for (int num90 = 0; (double)num90 < dmg / (double)lifeMax * 50.0; num90++)
                {
                    Dust dust15 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust15.color = color2;
                    dust15.noGravity = true;
                    dust15.scale = 1.5f;
                    dust15.fadeIn = 0.7f;
                    Dust dust = dust15;
                    dust.velocity *= 3f;
                    dust15 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust15.color = color2;
                    dust15.noGravity = true;
                    dust15.scale = 1.5f;
                    dust15.fadeIn = 0.7f;
                    dust = dust15;
                    dust.velocity *= 3f;
                }
            }
            else
            {
                for (int num91 = 0; num91 < 20; num91++)
                {
                    Dust dust16 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust16.color = color2;
                    dust16.noGravity = true;
                    dust16.scale = 1.5f;
                    dust16.fadeIn = 0.7f;
                    Dust dust = dust16;
                    dust.velocity *= 3f;
                    dust16 = Main.dust[Dust.NewDust(position, width, height, 268)];
                    dust16.color = color2;
                    dust16.noGravity = true;
                    dust16.scale = 1.5f;
                    dust16.fadeIn = 0.7f;
                    dust = dust16;
                    dust.velocity *= 3f;
                }
                for (int num92 = 0; num92 < 20; num92++)
                {
                    int num93 = Dust.NewDust(position, width, height, 54, 0f, 0f, 50, default(Color), 1.5f);
                    Dust dust = Main.dust[num93];
                    dust.velocity *= 2f;
                    Main.dust[num93].noGravity = true;
                }
                Gore.NewGore(position, velocity, 964, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 965, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 966, scale);
            }
        }
        if (type == 378)
        {
            if (life > 0)
            {
                for (int num94 = 0; (double)num94 < dmg / (double)lifeMax * 50.0; num94++)
                {
                    Dust.NewDust(position, width, height, 7);
                }
            }
            else
            {
                for (int num95 = 0; num95 < 20; num95++)
                {
                    Dust.NewDust(position, width, height, 7);
                }
            }
        }
        if (type == 437 && dmg == 9999.0)
        {
            for (int num96 = 0; num96 < 6; num96++)
            {
                int num97 = Gore.NewGore(base.Center - new Vector2(10f), Vector2.UnitY.RotatedByRandom(6.2831854820251465) * 5f, 728 + num96);
            }
        }
        if (type == 398 && dmg == 1337.0 && Main.netMode != 2)
        {
            MoonlordDeathDrama.ThrowPieces(base.Center, Main.rand.Next(100));
        }
        if (type == 488)
        {
            localAI[0] = (int)dmg;
            if (localAI[0] < 20f)
            {
                localAI[0] = 20f;
            }
            if (localAI[0] > 120f)
            {
                localAI[0] = 120f;
            }
            localAI[1] = hitDirection;
        }
        if (type == 583 || type == 584 || type == 585)
        {
            Color value = Color.HotPink;
            Color value2 = Color.LightPink;
            int num98 = 4;
            if (type == 584)
            {
                value = Color.LimeGreen;
                value2 = Color.LightSeaGreen;
            }
            if (type == 585)
            {
                value = Color.RoyalBlue;
                value2 = Color.LightBlue;
            }
            if (life > 0)
            {
                for (int num99 = 0; (double)num99 < dmg / (double)lifeMax * 50.0; num99++)
                {
                    Dust dust17 = Dust.NewDustDirect(base.Center - new Vector2(num98) * 0.5f, num98 + 4, num98 + 4, 278, 0f, 0f, 200, Color.Lerp(value, value2, Main.rand.NextFloat()), 0.65f);
                    dust17.noGravity = true;
                }
            }
            else
            {
                for (int num100 = 0; num100 < 20; num100++)
                {
                    Dust dust18 = Dust.NewDustDirect(base.Center - new Vector2(num98) * 0.5f, num98 + 4, num98 + 4, 278, 0f, 0f, 200, Color.Lerp(value, value2, Main.rand.NextFloat()), 0.65f);
                    Dust dust = dust18;
                    dust.velocity *= 1.5f;
                    dust18.noGravity = true;
                }
            }
        }
        else if (type >= 513 && type <= 515)
        {
            if (life > 0)
            {
                for (int num101 = 0; (double)num101 < dmg / (double)lifeMax * 100.0; num101++)
                {
                    Dust.NewDust(position, width, height, 250, hitDirection, -1f, alpha, this.color, scale);
                }
            }
            else
            {
                for (int num102 = 0; num102 < 50; num102++)
                {
                    Dust.NewDust(position, width, height, 250, hitDirection, -2f, alpha, this.color, scale);
                }
                int num103 = Gore.NewGore(position, velocity, type - 513 + 822);
                Main.gore[num103].alpha = alpha;
            }
        }
        else if (type >= 510 && type <= 512)
        {
            if (life > 0)
            {
                for (int num104 = 0; (double)num104 < dmg / (double)lifeMax * 100.0; num104++)
                {
                    Dust.NewDust(position, width, height, 250, hitDirection, -1f, alpha, this.color, scale);
                }
            }
            else
            {
                for (int num105 = 0; num105 < 50; num105++)
                {
                    Dust.NewDust(position, width, height, 250, hitDirection, -2f, alpha, this.color, scale);
                }
                int num106 = Gore.NewGore(position, velocity, type - 510 + 819);
                Main.gore[num106].alpha = alpha;
            }
        }
        else if (type >= 621 && type <= 623)
        {
            if (life > 0)
            {
                for (int num107 = 0; (double)num107 < dmg / (double)lifeMax * 100.0; num107++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f, alpha, this.color, scale);
                }
            }
            else
            {
                for (int num108 = 0; num108 < 50; num108++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -2f, alpha, this.color, scale);
                }
                int num109 = Gore.NewGore(position, velocity, type - 621 + 1187);
                Main.gore[num109].alpha = alpha;
            }
        }
        else if (type == 518 || type == 416)
        {
            if (life > 0)
            {
                for (int num110 = 0; (double)num110 < dmg / (double)lifeMax * 20.0; num110++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust19 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust19.noGravity = true;
                        dust19.scale = 1.5f;
                        dust19.fadeIn = 1f;
                        Dust dust = dust19;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num111 = 0; num111 < 20; num111++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust dust20 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust20.noGravity = true;
                        dust20.scale = 1.5f;
                        dust20.fadeIn = 1f;
                        Dust dust = dust20;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, 844, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 845, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 847, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 835, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 836, scale);
            }
        }
        else if (type == 419)
        {
            if (life > 0)
            {
                for (int num112 = 0; (double)num112 < dmg / (double)lifeMax * 20.0; num112++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust21 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust21.noGravity = true;
                        dust21.scale = 1.5f;
                        dust21.fadeIn = 1f;
                        Dust dust = dust21;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num113 = 0; num113 < 20; num113++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust dust22 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust22.noGravity = true;
                        dust22.scale = 1.5f;
                        dust22.fadeIn = 1f;
                        Dust dust = dust22;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, 844, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 845, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 846, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 846, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 847, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 847, scale);
            }
        }
        else if (type == 412 || type == 413 || type == 414)
        {
            if (life > 0)
            {
                for (int num114 = 0; (double)num114 < dmg / (double)lifeMax * 50.0; num114++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                }
            }
            else
            {
                for (int num115 = 0; num115 < 6; num115++)
                {
                    Dust.NewDust(position, width, height, 241, 2.5f * (float)hitDirection, -2.5f);
                }
                for (int num116 = 0; num116 < 2; num116++)
                {
                    Dust.NewDust(position, width, height, 6, 2.5f * (float)hitDirection, -2.5f, 100, Color.Transparent, 2f);
                }
                Gore.NewGore(position, velocity, type - 412 + 828);
            }
        }
        else if (type == 415)
        {
            if (life > 0)
            {
                for (int num117 = 0; (double)num117 < dmg / (double)lifeMax * 20.0; num117++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust23 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust23.noGravity = true;
                        dust23.scale = 1.5f;
                        dust23.fadeIn = 1f;
                        Dust dust = dust23;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num118 = 0; num118 < 40; num118++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    Dust dust24 = Main.dust[Dust.NewDust(position, width, height, 6)];
                    dust24.noGravity = true;
                    dust24.scale = 1.5f;
                    dust24.fadeIn = 1f;
                    Dust dust = dust24;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 831);
                Gore.NewGore(base.Center, velocity * 0.8f, 832);
                Gore.NewGore(base.Center, velocity * 0.9f, 833);
                Gore.NewGore(base.Center, velocity * 0.9f, 834);
            }
        }
        else if (type == 417)
        {
            if (life > 0)
            {
                for (int num119 = 0; (double)num119 < dmg / (double)lifeMax * 20.0; num119++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust25 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust25.noGravity = true;
                        dust25.scale = 1.5f;
                        dust25.fadeIn = 1f;
                        Dust dust = dust25;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num120 = 0; num120 < 30; num120++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust26 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust26.noGravity = true;
                        dust26.scale = 1.5f;
                        dust26.fadeIn = 1f;
                        Dust dust = dust26;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, 837, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 838, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 838, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 838, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 839, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 839, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 38f), velocity, 840, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 38f), velocity, 840, scale);
            }
        }
        else if (type == 418)
        {
            if (life > 0)
            {
                for (int num121 = 0; (double)num121 < dmg / (double)lifeMax * 20.0; num121++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust27 = Main.dust[Dust.NewDust(position, width, height, 6)];
                        dust27.noGravity = true;
                        dust27.scale = 1.5f;
                        dust27.fadeIn = 1f;
                        Dust dust = dust27;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num122 = 0; num122 < 20; num122++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    Dust dust28 = Main.dust[Dust.NewDust(position, width, height, 6)];
                    dust28.noGravity = true;
                    dust28.scale = 1.5f;
                    dust28.fadeIn = 1f;
                    Dust dust = dust28;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 841);
                Gore.NewGore(base.Center, velocity * 0.8f, 842);
                Gore.NewGore(base.Center, velocity * 0.8f, 842);
                Gore.NewGore(base.Center, velocity * 0.9f, 843);
                Gore.NewGore(base.Center, velocity * 0.9f, 843);
            }
        }
        if (type == 516)
        {
            for (int num123 = 0; num123 < 20; num123++)
            {
                int num124 = Dust.NewDust(position, width, height, 6, 2.5f * (float)hitDirection, -2.5f);
                Dust dust = Main.dust[num124];
                dust.velocity *= 3f;
                dust = Main.dust[num124];
                dust.scale += Main.rand.NextFloat();
                if (Main.rand.Next(2) == 0)
                {
                    num124 = Dust.NewDust(position, width, height, 259, 2.5f * (float)hitDirection, -2.5f);
                    Main.dust[num124].noGravity = true;
                }
            }
        }
        if (type == 519)
        {
            Rectangle hitbox2 = base.Hitbox;
            for (int num125 = 0; num125 < oldPos.Length; num125 += 3)
            {
                hitbox2.X = (int)oldPos[num125].X;
                hitbox2.Y = (int)oldPos[num125].Y;
                for (int num126 = 0; num126 < 5; num126++)
                {
                    int num127 = Utils.SelectRandom<int>(Main.rand, 6, 259, 158);
                    int num128 = Dust.NewDust(hitbox2.TopLeft(), width, height, num127, 2.5f * (float)hitDirection, -2.5f);
                    Main.dust[num128].alpha = 200;
                    Dust dust = Main.dust[num128];
                    dust.velocity *= 2.4f;
                    dust = Main.dust[num128];
                    dust.scale += Main.rand.NextFloat();
                }
            }
        }
        if (type == 522)
        {
            Vector2 spinningpoint = new Vector2(0f, -3f).RotatedByRandom(3.1415927410125732);
            float num129 = 24f;
            Vector2 vector14 = new Vector2(1.05f, 1f);
            for (float num130 = 0f; num130 < num129; num130++)
            {
                int num131 = Dust.NewDust(base.Center, 0, 0, 66, 0f, 0f, 0, Color.Transparent);
                Main.dust[num131].position = base.Center;
                Main.dust[num131].velocity = spinningpoint.RotatedBy((float)Math.PI * 2f * num130 / num129) * vector14 * (0.8f + Main.rand.NextFloat() * 0.4f) * 2f;
                Main.dust[num131].color = Color.SkyBlue;
                Main.dust[num131].noGravity = true;
                Dust dust = Main.dust[num131];
                dust.scale += 0.5f + Main.rand.NextFloat();
            }
        }
        else if (type == 426)
        {
            if (life > 0)
            {
                for (int num132 = 0; (double)num132 < dmg / (double)lifeMax * 50.0; num132++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust29 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust29.noGravity = true;
                        dust29.scale = 1.5f;
                        dust29.fadeIn = 1f;
                        Dust dust = dust29;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num133 = 0; num133 < 20; num133++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                }
                for (int num134 = 0; num134 < 30; num134++)
                {
                    int num135 = Utils.SelectRandom<int>(Main.rand, 229, 240, 161);
                    Dust dust30 = Main.dust[Dust.NewDust(position, width, height, num135)];
                    dust30.noGravity = true;
                    dust30.scale = 1.25f + Main.rand.NextFloat();
                    dust30.fadeIn = 0.25f;
                    Dust dust = dust30;
                    dust.velocity *= 2f;
                    dust30.noLight = true;
                }
                Gore.NewGore(base.Top, velocity * 0.7f, 799);
                Gore.NewGore(base.Center, velocity * 0.8f, 800);
                Gore.NewGore(base.Center, velocity * 0.9f, 801);
                if (Main.netMode != 1)
                {
                    int num136 = CountNPCS(428) + CountNPCS(427) + CountNPCS(426) * 3;
                    int num137 = 20;
                    if (num136 < num137)
                    {
                        for (int num138 = 0; num138 < 3; num138++)
                        {
                            int num139 = NewNPC(GetSpawnSource_NPCHurt(), (int)base.Center.X, (int)base.Center.Y, 428, whoAmI);
                            Main.npc[num139].velocity = -Vector2.UnitY.RotatedByRandom(6.2831854820251465) * Main.rand.Next(3, 6) - Vector2.UnitY * 2f;
                            Main.npc[num139].netUpdate = true;
                        }
                    }
                }
            }
        }
        else if (type == 427)
        {
            if (life > 0)
            {
                for (int num140 = 0; (double)num140 < dmg / (double)lifeMax * 20.0; num140++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust31 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust31.noGravity = true;
                        dust31.scale = 1.5f;
                        dust31.fadeIn = 1f;
                        Dust dust = dust31;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num141 = 0; num141 < 10; num141++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                }
                for (int num142 = 0; num142 < 20; num142++)
                {
                    int num143 = Utils.SelectRandom<int>(Main.rand, 229, 229, 240);
                    Dust dust32 = Main.dust[Dust.NewDust(position, width, height, num143)];
                    dust32.noGravity = true;
                    dust32.scale = 1.25f + Main.rand.NextFloat();
                    dust32.fadeIn = 0.25f;
                    Dust dust = dust32;
                    dust.velocity *= 3f;
                    dust32.noLight = true;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 802);
                Gore.NewGore(base.Center, velocity * 0.9f, 803);
                Gore.NewGore(base.Center, velocity * 0.9f, 804);
                Gore.NewGore(base.Center, velocity * 0.8f, 805);
            }
        }
        else if (type == 429)
        {
            if (life > 0)
            {
                for (int num144 = 0; (double)num144 < dmg / (double)lifeMax * 20.0; num144++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust33 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust33.noGravity = true;
                        dust33.scale = 1.5f;
                        dust33.fadeIn = 1f;
                        Dust dust = dust33;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num145 = 0; num145 < 20; num145++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust dust34 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust34.noGravity = true;
                        dust34.scale = 1.5f;
                        dust34.fadeIn = 1f;
                        Dust dust = dust34;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, 808, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 809, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 809, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 810, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 810, scale);
                if (Main.netMode != 1)
                {
                    Point point = base.Center.ToTileCoordinates();
                    Point point2 = Main.player[target].Center.ToTileCoordinates();
                    Vector2 vector15 = Main.player[target].Center - base.Center;
                    int num146 = 20;
                    int num147 = 3;
                    int num148 = 7;
                    int num149 = 2;
                    int num150 = 0;
                    bool flag2 = false;
                    if (vector15.Length() > 2000f)
                    {
                        flag2 = true;
                    }
                    while (!flag2 && num150 < 100)
                    {
                        num150++;
                        int num151 = Main.rand.Next(point2.X - num146, point2.X + num146 + 1);
                        int num152 = Main.rand.Next(point2.Y - num146, point2.Y - Math.Abs(num151 - point2.X) + 1);
                        if ((num152 < point2.Y - num148 || num152 > point2.Y + num148 || num151 < point2.X - num148 || num151 > point2.X + num148) && (num152 < point.Y - num147 || num152 > point.Y + num147 || num151 < point.X - num147 || num151 > point.X + num147) && !Main.tile[num151, num152].nactive())
                        {
                            bool flag3 = true;
                            if (flag3 && Main.tile[num151, num152].lava())
                            {
                                flag3 = false;
                            }
                            if (flag3 && Collision.SolidTiles(num151 - num149, num151 + num149, num152 - num149, num152 + num149))
                            {
                                flag3 = false;
                            }
                            if (flag3 && !Collision.CanHitLine(base.Center, 0, 0, Main.player[target].Center, 0, 0))
                            {
                                flag3 = false;
                            }
                            if (flag3)
                            {
                                Projectile.NewProjectile(GetSpawnSource_ForProjectile(), num151 * 16 + 8, num152 * 16 + 8, 0f, 0f, 578, 0, 1f, Main.myPlayer);
                                flag2 = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        else if (type == 425)
        {
            if (life > 0)
            {
                for (int num153 = 0; (double)num153 < dmg / (double)lifeMax * 20.0; num153++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust35 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust35.noGravity = true;
                        dust35.scale = 1.5f;
                        dust35.fadeIn = 1f;
                        Dust dust = dust35;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num154 = 0; num154 < 20; num154++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust dust36 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust36.noGravity = true;
                        dust36.scale = 1.5f;
                        dust36.fadeIn = 1f;
                        Dust dust = dust36;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, 796, scale);
                Gore.NewGore(base.Center, velocity, 797, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 798, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 809, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 809, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 810, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 810, scale);
            }
        }
        else if (type == 428)
        {
            if (life > 0)
            {
                for (int num155 = 0; (double)num155 < dmg / (double)lifeMax * 20.0; num155++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                }
            }
            else
            {
                for (int num156 = 0; num156 < 10; num156++)
                {
                    Dust.NewDust(position, width, height, 241, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust.NewDust(position, width, height, 229);
                    }
                    else
                    {
                        Dust.NewDust(position, width, height, 240);
                    }
                }
                Gore.NewGore(position, velocity * 0.8f, 806);
                Gore.NewGore(position, velocity * 0.8f, 807);
            }
        }
        else if (type == 424)
        {
            if (life > 0)
            {
                for (int num157 = 0; (double)num157 < dmg / (double)lifeMax * 20.0; num157++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust37 = Main.dust[Dust.NewDust(position, width, height, 242)];
                        dust37.noGravity = true;
                        dust37.scale = 1.5f;
                        dust37.fadeIn = 1f;
                        Dust dust = dust37;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num158 = 0; num158 < 20; num158++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust dust38 = Main.dust[Dust.NewDust(position, width, height, 242)];
                        dust38.noGravity = true;
                        dust38.scale = 1.5f;
                        dust38.fadeIn = 1f;
                        Dust dust = dust38;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, 793, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 794, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 794, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 795, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 795, scale);
            }
        }
        else if (type == 423)
        {
            if (life > 0)
            {
                for (int num159 = 0; (double)num159 < dmg / (double)lifeMax * 50.0; num159++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust39 = Main.dust[Dust.NewDust(position, width, height, 242)];
                        dust39.noGravity = true;
                        dust39.scale = 1.5f;
                        dust39.fadeIn = 1f;
                        Dust dust = dust39;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num160 = 0; num160 < 20; num160++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    Dust dust40 = Main.dust[Dust.NewDust(position, width, height, 242)];
                    dust40.noGravity = true;
                    dust40.scale = 1.5f;
                    dust40.fadeIn = 1f;
                    Dust dust = dust40;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 790);
                Gore.NewGore(base.Center, velocity * 0.8f, 791);
                Gore.NewGore(base.Center, velocity * 0.9f, 792);
            }
        }
        else if (type == 421)
        {
            if (life > 0)
            {
                for (int num161 = 0; (double)num161 < dmg / (double)lifeMax * 20.0; num161++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust41 = Main.dust[Dust.NewDust(position, width, height, 242)];
                        dust41.noGravity = true;
                        dust41.scale = 1.5f;
                        dust41.fadeIn = 1f;
                        Dust dust = dust41;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num162 = 0; num162 < 10; num162++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    Dust dust42 = Main.dust[Dust.NewDust(position, width, height, 242)];
                    dust42.noGravity = true;
                    dust42.scale = 1.5f;
                    dust42.fadeIn = 1f;
                    Dust dust = dust42;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 785);
                Gore.NewGore(base.Center, velocity * 0.8f, 786);
                Gore.NewGore(base.Center, velocity * 0.9f, 787);
            }
        }
        else if (type == 420)
        {
            if (life > 0)
            {
                for (int num163 = 0; (double)num163 < dmg / (double)lifeMax * 20.0; num163++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust43 = Main.dust[Dust.NewDust(position, width, height, 242)];
                        dust43.noGravity = true;
                        dust43.scale = 1.5f;
                        dust43.fadeIn = 1f;
                        Dust dust = dust43;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num164 = 0; num164 < 10; num164++)
                {
                    Dust.NewDust(position, width, height, 249, hitDirection, -1f);
                    Dust dust44 = Main.dust[Dust.NewDust(position, width, height, 242)];
                    dust44.noGravity = true;
                    dust44.scale = 1.5f;
                    dust44.fadeIn = 1f;
                    Dust dust = dust44;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 782);
                Gore.NewGore(base.Center, velocity * 0.8f, 783);
                Gore.NewGore(base.Center, velocity * 0.9f, 784);
            }
        }
        else if (type == 406 || type == 405)
        {
            if (life > 0)
            {
                for (int num165 = 0; (double)num165 < 10.0 + dmg / 10.0; num165++)
                {
                    int num166 = width / 4;
                    Vector2 vector16 = ((float)Main.rand.NextDouble() * ((float)Math.PI * 2f)).ToRotationVector2() * Main.rand.Next(24, 41) / 8f;
                    int num167 = Dust.NewDust(base.Center - Vector2.One * num166, num166 * 2, num166 * 2, 229);
                    Dust dust45 = Main.dust[num167];
                    Vector2 vector17 = Vector2.Normalize(dust45.position - base.Center);
                    dust45.position = base.Center + vector17 * num166 * scale - new Vector2(4f);
                    if (num165 < 30)
                    {
                        dust45.velocity = vector17 * dust45.velocity.Length() * 2f;
                    }
                    else
                    {
                        dust45.velocity = 2f * vector17 * Main.rand.Next(45, 91) / 10f;
                    }
                    dust45.noGravity = true;
                    dust45.scale = 0.7f + Main.rand.NextFloat();
                }
            }
            else
            {
                for (int num168 = 0; num168 < 60; num168++)
                {
                    int num169 = width / 4;
                    Vector2 vector18 = ((float)Main.rand.NextDouble() * ((float)Math.PI * 2f)).ToRotationVector2() * Main.rand.Next(24, 41) / 8f;
                    int num170 = Dust.NewDust(base.Center - Vector2.One * num169, num169 * 2, num169 * 2, 229);
                    Dust dust46 = Main.dust[num170];
                    Vector2 vector19 = Vector2.Normalize(dust46.position - base.Center);
                    dust46.position = base.Center + vector19 * num169 * scale - new Vector2(4f);
                    if (num168 < 30)
                    {
                        dust46.velocity = vector19 * dust46.velocity.Length() * 2f;
                    }
                    else
                    {
                        dust46.velocity = 2f * vector19 * Main.rand.Next(45, 91) / 10f;
                    }
                    dust46.noGravity = true;
                    dust46.scale = 0.7f;
                }
                if (type == 405)
                {
                    int num171 = CountNPCS(406) + CountNPCS(405);
                    int num172 = 4;
                    if (num171 >= 4)
                    {
                        num172 = 3;
                    }
                    if (num171 >= 7)
                    {
                        num172 = 2;
                    }
                    if (num171 >= 10)
                    {
                        num172 = 1;
                    }
                    for (int num173 = 0; num173 < num172; num173++)
                    {
                        Vector2 vector20 = Vector2.UnitY.RotatedByRandom(6.2831854820251465) * (3f + Main.rand.NextFloat() * 4f);
                        int num174 = NewNPC(GetSpawnSource_NPCHurt(), (int)base.Center.X, (int)base.Bottom.Y, 406, whoAmI);
                        Main.npc[num174].velocity = vector20;
                    }
                }
            }
        }
        else if (type == 409)
        {
            if (life > 0)
            {
                for (int num175 = 0; (double)num175 < dmg / (double)lifeMax * 50.0; num175++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust47 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust47.noGravity = true;
                    }
                }
            }
            else
            {
                for (int num176 = 0; num176 < 20; num176++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    Dust dust48 = Main.dust[Dust.NewDust(position, width, height, 229)];
                    dust48.noGravity = true;
                    Dust dust = dust48;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 775);
                Gore.NewGore(base.Center, velocity * 0.8f, 776);
                Gore.NewGore(base.Center, velocity * 0.9f, 777);
            }
        }
        else if (type == 410)
        {
            if (life > 0)
            {
                for (int num177 = 0; (double)num177 < dmg / (double)lifeMax * 10.0; num177++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust49 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust49.noGravity = true;
                    }
                }
            }
            else
            {
                for (int num178 = 0; num178 < 5; num178++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    Dust dust50 = Main.dust[Dust.NewDust(position, width, height, 229)];
                    dust50.noGravity = true;
                    Dust dust = dust50;
                    dust.velocity *= 3f;
                }
            }
        }
        else if (type == 407)
        {
            if (life > 0)
            {
                for (int num179 = 0; (double)num179 < dmg / (double)lifeMax * 50.0; num179++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f, 0, Color.Transparent, 0.75f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust51 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust51.noGravity = true;
                    }
                }
            }
            else
            {
                for (int num180 = 0; num180 < 20; num180++)
                {
                    if (Main.rand.Next(3) != 0)
                    {
                        Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    }
                    Dust dust52 = Main.dust[Dust.NewDust(position, width, height, 229)];
                    dust52.noGravity = true;
                    Dust dust = dust52;
                    dust.velocity *= 3f;
                }
                Gore.NewGore(base.Top, velocity * 0.8f, 778);
                Gore.NewGore(base.Top, velocity * 0.8f, 779);
                Gore.NewGore(base.Center, velocity * 0.9f, 780);
                Gore.NewGore(base.Center, velocity * 0.9f, 781);
                Gore.NewGore(base.Center, velocity * 0.9f, 780);
                Gore.NewGore(base.Center, velocity * 0.9f, 781);
            }
        }
        else if (type == 402)
        {
            if (life > 0)
            {
                for (int num181 = 0; (double)num181 < dmg / (double)lifeMax * 3.0; num181++)
                {
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust.NewDust(position, width, height, 17, hitDirection, -1f, 0, Color.Transparent, 0.75f);
                    }
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust53 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust53.noGravity = true;
                    }
                    for (int num182 = 0; num182 < oldPos.Length; num182++)
                    {
                        if (Main.rand.Next(4) == 0)
                        {
                            if (oldPos[num182] == Vector2.Zero)
                            {
                                break;
                            }
                            if (Main.rand.Next(3) == 0)
                            {
                                Dust.NewDust(oldPos[num182], width, height, 17, hitDirection, -1f, 0, Color.Transparent, 0.75f);
                            }
                            if (Main.rand.Next(2) == 0)
                            {
                                Dust dust54 = Main.dust[Dust.NewDust(oldPos[num182], width, height, 229)];
                                dust54.noGravity = true;
                            }
                        }
                    }
                }
            }
            else
            {
                for (int num183 = 0; num183 < 5; num183++)
                {
                    if (Main.rand.Next(3) == 0)
                    {
                        Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    }
                    Dust dust55 = Main.dust[Dust.NewDust(position, width, height, 229)];
                    dust55.noGravity = true;
                    Dust dust = dust55;
                    dust.velocity *= 3f;
                }
                for (int num184 = 0; num184 < oldPos.Length; num184++)
                {
                    if (Main.rand.Next(4) != 0)
                    {
                        continue;
                    }
                    if (oldPos[num184] == Vector2.Zero)
                    {
                        break;
                    }
                    for (int num185 = 0; num185 < 2; num185++)
                    {
                        if (Main.rand.Next(3) == 0)
                        {
                            Dust.NewDust(oldPos[num184], width, height, 17, hitDirection, -1f);
                        }
                        Dust dust56 = Main.dust[Dust.NewDust(oldPos[num184], width, height, 229)];
                        dust56.noGravity = true;
                        Dust dust = dust56;
                        dust.velocity *= 3f;
                    }
                }
            }
        }
        else if (type == 411)
        {
            if (life > 0)
            {
                for (int num186 = 0; (double)num186 < dmg / (double)lifeMax * 20.0; num186++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0)
                    {
                        Dust dust57 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust57.noGravity = true;
                    }
                }
            }
            else
            {
                for (int num187 = 0; num187 < 20; num187++)
                {
                    Dust.NewDust(position, width, height, 17, hitDirection, -1f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Dust dust58 = Main.dust[Dust.NewDust(position, width, height, 229)];
                        dust58.noGravity = true;
                    }
                }
                Gore.NewGore(position, velocity, 772, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 773, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 773, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 774, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 774, scale);
            }
        }
        else if (type == 491)
        {
            if (life <= 0)
            {
                Vector2 vector21 = base.Center - new Vector2(60f);
                Vector2 vector22 = new Vector2((spriteDirection != 1) ? 1 : (-1), 0f).RotatedBy(rotation);
                Gore.NewGore(vector21 + vector22 * (width / 2), velocity, 858, scale);
                Gore.NewGore(vector21 + vector22 * (width / 3), velocity, 857, scale);
                for (int num188 = -1; num188 < 2; num188++)
                {
                    Gore.NewGore(vector21 + vector22 * ((float)width * (0.45f + (float)num188 * 0.1f)), velocity, 859, scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * (0.4f + (float)num188 * 0.1f)), velocity, 859, scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * (0.35f + (float)num188 * 0.1f)), velocity, 859, scale);
                }
                for (int num189 = -1; num189 < 2; num189++)
                {
                    Gore.NewGore(vector21 + vector22 * ((float)width * 0.35f) - new Vector2(0f, 200f) + Utils.RandomVector2(Main.rand, -40f, 40f), velocity, Utils.SelectRandom<int>(Main.rand, 860, 892, 893), scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * 0.15f) - new Vector2(0f, 200f) + Utils.RandomVector2(Main.rand, -40f, 40f), velocity, Utils.SelectRandom<int>(Main.rand, 860, 892, 893), scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * -0.35f) - new Vector2(0f, 200f) + Utils.RandomVector2(Main.rand, -40f, 40f), velocity, Utils.SelectRandom<int>(Main.rand, 860, 892, 893), scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * -0.15f) - new Vector2(0f, 300f) + Utils.RandomVector2(Main.rand, -40f, 40f), velocity, Utils.SelectRandom<int>(Main.rand, 860, 892, 893), scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * -0.15f) - new Vector2(0f, 300f) + Utils.RandomVector2(Main.rand, -40f, 40f), velocity, Utils.SelectRandom<int>(Main.rand, 860, 892, 893), scale);
                }
                for (int num190 = 0; num190 < 2; num190++)
                {
                    Gore.NewGore(vector21 + vector22 * ((float)width * 0.15f) - new Vector2(0f, 160 + 60 * num190), velocity, 855, scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * -0.15f) - new Vector2(0f, 160 + 60 * num190), velocity, 855, scale);
                }
                for (int num191 = -1; num191 < 2; num191++)
                {
                    Gore.NewGore(vector21 + vector22 * ((float)width * (0.25f + (float)num191 * 0.1f)) - new Vector2(0f, 20 + 40 * num191), velocity, 854, scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * (-0.45f + (float)num191 * 0.1f)) - new Vector2(0f, 20 + 40 * num191), velocity, 853, scale);
                    Gore.NewGore(vector21 + vector22 * ((float)width * (0.05f + (float)num191 * 0.1f)) - new Vector2(0f, 20 + 40 * num191), velocity, 856, scale);
                }
                for (int num192 = 0; num192 < 30; num192++)
                {
                    int num193 = Main.rand.Next(861, 863);
                    int num194 = Gore.NewGore(base.Center - new Vector2(60f), Vector2.Zero, num193);
                    Main.gore[num194].alpha = 100;
                    Main.gore[num194].velocity = Vector2.Transform(new Vector2(4f, 0f), Matrix.CreateRotationZ((float)(Main.rand.NextDouble() * 6.2831854820251465)));
                    Main.gore[num194].position = new Vector2(position.X - 20f + ((float)width + 40f) * Main.rand.NextFloat(), position.Y - 240f + (float)(height + 240 - 20) * Main.rand.NextFloat());
                }
                for (int num195 = 0; num195 < 120; num195++)
                {
                    int num196 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                    Main.dust[num196].noGravity = true;
                    Dust dust = Main.dust[num196];
                    dust.velocity *= 5f;
                    num196 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                    dust = Main.dust[num196];
                    dust.velocity *= 4f;
                    Main.dust[num196].noGravity = true;
                }
                if (Main.netMode != 1)
                {
                    for (int num197 = 0; num197 < 4; num197++)
                    {
                        float num198 = (float)(num197 < 2).ToDirectionInt() * ((float)Math.PI / 8f + (float)Math.PI / 4f * Main.rand.NextFloat());
                        Vector2 vector23 = new Vector2(0f, (0f - Main.rand.NextFloat()) * 0.5f - 0.5f).RotatedBy(num198) * 6f;
                        Projectile.NewProjectile(GetSpawnSource_ForProjectile(), base.Center.X, base.Center.Y, vector23.X, vector23.Y, 594, 0, 0f, Main.myPlayer);
                    }
                }
            }
        }
        else if (type == 492)
        {
            if (life <= 0)
            {
                for (int num199 = 0; num199 < 7; num199++)
                {
                    int num200 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                    Dust dust = Main.dust[num200];
                    dust.velocity *= 1.4f;
                }
                for (int num201 = 0; num201 < 10; num201++)
                {
                    int num202 = Main.rand.Next(61, 64);
                    int num203 = Gore.NewGore(position, Vector2.Zero, num202);
                    Main.gore[num203].alpha = 100;
                    Main.gore[num203].velocity = Vector2.Transform(new Vector2(1f, 0f), Matrix.CreateRotationZ((float)(Main.rand.NextDouble() * 6.2831854820251465)));
                }
            }
        }
        else if (type >= 524 && type <= 527)
        {
            int num204 = 0;
            int num205 = 5;
            int num206 = 863;
            if (type == 525)
            {
                num204 = 75;
                num206 = 867;
            }
            else if (type == 526)
            {
                num204 = 170;
                num206 = 871;
            }
            else if (type == 527)
            {
                num204 = 67;
                num206 = 879;
            }
            if (life > 0)
            {
                for (int num207 = 0; (double)num207 < dmg / (double)lifeMax * 20.0; num207++)
                {
                    Dust.NewDust(position, width, height, num205, hitDirection, -1f);
                    if (Main.rand.Next(4) == 0 && num204 > 0)
                    {
                        Dust dust59 = Main.dust[Dust.NewDust(position, width, height, num204)];
                        dust59.noGravity = true;
                        dust59.scale = 1.5f;
                        dust59.fadeIn = 1f;
                        Dust dust = dust59;
                        dust.velocity *= 3f;
                    }
                }
            }
            else
            {
                for (int num208 = 0; num208 < 20; num208++)
                {
                    Dust.NewDust(position, width, height, num205, hitDirection, -1f);
                    if (Main.rand.Next(3) == 0 && num204 > 0)
                    {
                        Dust dust60 = Main.dust[Dust.NewDust(position, width, height, num204)];
                        dust60.noGravity = true;
                        dust60.scale = 1.5f;
                        dust60.fadeIn = 1f;
                        Dust dust = dust60;
                        dust.velocity *= 3f;
                    }
                }
                Gore.NewGore(position, velocity, num206, scale);
                Gore.NewGore(position, velocity, num206 + 1, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num206 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num206 + 2, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num206 + 3, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num206 + 3, scale);
            }
        }
        else if (type >= 528 && type <= 529)
        {
            int num209 = 5;
            int num210 = 875;
            if (type == 529)
            {
                num210 = 876;
            }
            if (life > 0)
            {
                for (int num211 = 0; (double)num211 < dmg / (double)lifeMax * 20.0; num211++)
                {
                    Dust.NewDust(position, width, height, num209, hitDirection, -1f);
                }
            }
            else
            {
                for (int num212 = 0; num212 < 20; num212++)
                {
                    Dust.NewDust(position, width, height, num209, hitDirection, -1f);
                }
                Gore.NewGore(position, velocity, num210, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 877, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 877, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 878, scale);
            }
        }
        else if (type == 530 || type == 531)
        {
            if (life > 0)
            {
                for (int num213 = 0; (double)num213 < dmg / (double)lifeMax * 30.0; num213++)
                {
                    Dust.NewDust(position, width, height, 250, hitDirection, -1f, 100);
                }
            }
            else
            {
                for (int num214 = 0; num214 < 20; num214++)
                {
                    Dust.NewDust(position, width, height, 250, 2.5f * (float)hitDirection, -2.5f, 100);
                }
                Gore.NewGore(position, velocity, 883);
                Gore.NewGore(position, velocity, 884);
                Gore.NewGore(position, velocity, 885);
                Gore.NewGore(position, velocity, 886);
                Gore.NewGore(position, velocity, 887);
            }
        }
        else if (type == 532)
        {
            if (life > 0)
            {
                for (int num215 = 0; (double)num215 < dmg / (double)lifeMax * 50.0; num215++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f, 100);
                }
            }
            else
            {
                for (int num216 = 0; num216 < 50; num216++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f, 100);
                }
                Gore.NewGore(position, velocity, 888);
                Gore.NewGore(position, velocity, 889);
                Gore.NewGore(position, velocity, 890);
                Gore.NewGore(position, velocity, 891);
            }
        }
        else if (type == 533)
        {
            if (life > 0)
            {
                for (int num217 = 0; (double)num217 < dmg / (double)lifeMax * 50.0; num217++)
                {
                    int num218 = Dust.NewDust(position, width, height, 27, 0f, 0f, 50, default(Color), 1.5f);
                    Dust dust = Main.dust[num218];
                    dust.velocity *= 2f;
                    Main.dust[num218].noGravity = true;
                }
            }
            else
            {
                for (int num219 = 0; num219 < 40; num219++)
                {
                    int num220 = Dust.NewDust(position, width, height, 27, 0f, 0f, 50, default(Color), 1.5f);
                    Dust dust = Main.dust[num220];
                    dust.velocity *= 2f;
                    Main.dust[num220].noGravity = true;
                    Main.dust[num220].fadeIn = 1f;
                }
            }
        }
        else if (type == 460)
        {
            if (life > 0)
            {
                for (int num221 = 0; (double)num221 < dmg / (double)lifeMax * 100.0; num221++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num222 = 0; num222 < 50; num222++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 643, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 645, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 644, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 646, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 646, scale);
            }
        }
        else if (type == 477)
        {
            if (life > 0)
            {
                for (int num223 = 0; (double)num223 < dmg / (double)lifeMax * 100.0; num223++)
                {
                    Dust.NewDust(position, width, height, 237, hitDirection, -1f);
                }
            }
            else
            {
                for (int num224 = 0; num224 < 50; num224++)
                {
                    Dust.NewDust(position, width, height, 237, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 687, scale);
                Gore.NewGore(position, velocity, 688, scale);
                Gore.NewGore(position, velocity, 689, scale);
                Gore.NewGore(position, velocity, 690, scale);
                Gore.NewGore(position, velocity, 691, scale);
            }
        }
        else if (type == 479)
        {
            if (life > 0)
            {
                for (int num225 = 0; (double)num225 < dmg / (double)lifeMax * 100.0; num225++)
                {
                    Dust.NewDust(position, width, height, 237, hitDirection, -1f);
                }
            }
            else
            {
                for (int num226 = 0; num226 < 50; num226++)
                {
                    Dust.NewDust(position, width, height, 237, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 681, scale);
                Gore.NewGore(position, velocity, 682, scale);
                Gore.NewGore(position, velocity, 683, scale);
            }
        }
        else if (type == 478)
        {
            if (life > 0)
            {
                for (int num227 = 0; num227 < 10; num227++)
                {
                    int num228 = Dust.NewDust(position, width, height, 238, hitDirection, -1f);
                    Main.dust[num228].noGravity = true;
                }
            }
            else
            {
                for (int num229 = 0; num229 < 50; num229++)
                {
                    Dust.NewDust(position, width, height, 237 + Main.rand.Next(2), 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 684, scale);
                Gore.NewGore(position, velocity, 685, scale);
                Gore.NewGore(position, velocity, 686, scale);
                Gore.NewGore(position, velocity, 684 + Main.rand.Next(3), scale);
            }
        }
        else if (type == 466)
        {
            if (life > 0)
            {
                for (int num230 = 0; (double)num230 < dmg / (double)lifeMax * 100.0; num230++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num231 = 0; num231 < 50; num231++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 656, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 657, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 659, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 658, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 658, scale);
            }
        }
        else if (type == 468)
        {
            if (life > 0)
            {
                for (int num232 = 0; (double)num232 < dmg / (double)lifeMax * 100.0; num232++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num233 = 0; num233 < 50; num233++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 662, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 663, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 663, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 664, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 664, scale);
            }
        }
        else if (type == 469)
        {
            if (life > 0)
            {
                for (int num234 = 0; (double)num234 < dmg / (double)lifeMax * 100.0; num234++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num235 = 0; num235 < 50; num235++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 665, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 666, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 666, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 667, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 667, scale);
            }
        }
        else if (type == 463)
        {
            if (life > 0)
            {
                for (int num236 = 0; (double)num236 < dmg / (double)lifeMax * 100.0; num236++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num237 = 0; num237 < 50; num237++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 653, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 654, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 654, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 655, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 655, scale);
            }
        }
        else if (type == 461)
        {
            if (life > 0)
            {
                for (int num238 = 0; (double)num238 < dmg / (double)lifeMax * 100.0; num238++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num239 = 0; num239 < 50; num239++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 647, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 648, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 648, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 649, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 649, scale);
            }
        }
        else if (type == 462)
        {
            if (life > 0)
            {
                for (int num240 = 0; (double)num240 < dmg / (double)lifeMax * 100.0; num240++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num241 = 0; num241 < 50; num241++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 650, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 651, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 651, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 652, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 652, scale);
            }
        }
        else if (type == 379 || type == 438)
        {
            if (life > 0)
            {
                for (int num242 = 0; (double)num242 < dmg / (double)(lifeMax * 50); num242++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num243 = 0; num243 < 30; num243++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 900, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 901, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 901, scale);
            }
        }
        else if (type == 439)
        {
            if (life > 0)
            {
                for (int num244 = 0; (double)num244 < dmg / (double)lifeMax * 100.0; num244++)
                {
                    int num245 = Dust.NewDust(position, width, height, 5, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num245];
                    dust.velocity *= 1.5f;
                    Main.dust[num245].noGravity = true;
                }
            }
            else
            {
                for (int num246 = 0; num246 < 30; num246++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                for (int num247 = 0; num247 < 10; num247++)
                {
                    int num248 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num248];
                    dust.velocity *= 2f;
                    Main.dust[num248].noGravity = true;
                }
                int num249 = Main.rand.Next(1, 4);
                for (int num250 = 0; num250 < num249; num250++)
                {
                    int num251 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), Main.rand.Next(11, 14), scale);
                    Gore gore2 = Main.gore[num251];
                    gore2.velocity *= 0.8f;
                }
                Gore.NewGore(position, velocity, 902, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 903, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 901, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 901, scale);
            }
        }
        else if (type == 440)
        {
            if (life <= 0)
            {
                for (int num252 = 0; num252 < 10; num252++)
                {
                    int num253 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num253];
                    dust.velocity *= 2f;
                    Main.dust[num253].noGravity = true;
                }
                int num254 = Main.rand.Next(1, 4);
                for (int num255 = 0; num255 < num254; num255++)
                {
                    int num256 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), Main.rand.Next(11, 14), scale);
                    Gore gore2 = Main.gore[num256];
                    gore2.velocity *= 0.8f;
                }
            }
        }
        else if (type >= 454 && type <= 459)
        {
            if (life > 0)
            {
                for (int num257 = 0; (double)num257 < dmg / (double)lifeMax * 50.0; num257++)
                {
                    int num258 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num258];
                    dust.velocity *= 1.5f;
                    Main.dust[num258].noGravity = true;
                }
            }
            else
            {
                for (int num259 = 0; num259 < 10; num259++)
                {
                    int num260 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num260];
                    dust.velocity *= 2f;
                    Main.dust[num260].noGravity = true;
                }
                int num261 = Main.rand.Next(1, 4);
                for (int num262 = 0; num262 < num261; num262++)
                {
                    int num263 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), Main.rand.Next(11, 14), scale);
                    Gore gore2 = Main.gore[num263];
                    gore2.velocity *= 0.8f;
                }
            }
        }
        if (type == 372 || type == 373)
        {
            if (life > 0)
            {
                for (int num264 = 0; (double)num264 < dmg / (double)lifeMax * 100.0; num264++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num265 = 0; num265 < 75; num265++)
                {
                    int num266 = Dust.NewDust(base.Center - Vector2.One * 25f, 50, 50, 5, 2 * hitDirection, -2f);
                    Dust dust = Main.dust[num266];
                    dust.velocity /= 2f;
                }
                Gore.NewGore(base.Center, velocity * 0.8f, 583);
                Gore.NewGore(base.Center, velocity * 0.8f, 577);
                Gore.NewGore(base.Center, velocity * 0.9f, 578);
                Gore.NewGore(base.Center, velocity, 579);
            }
        }
        if (type == 371)
        {
            SoundEngine.PlaySound(4, (int)position.X, (int)position.Y, 3);
            if (life <= 0)
            {
                Vector2 center = base.Center;
                for (int num267 = 0; num267 < 60; num267++)
                {
                    int num268 = 25;
                    Vector2 vector24 = ((float)Main.rand.NextDouble() * ((float)Math.PI * 2f)).ToRotationVector2() * Main.rand.Next(24, 41) / 8f;
                    int num269 = Dust.NewDust(base.Center - Vector2.One * num268, num268 * 2, num268 * 2, 212);
                    Dust dust61 = Main.dust[num269];
                    Vector2 vector25 = Vector2.Normalize(dust61.position - base.Center);
                    dust61.position = base.Center + vector25 * 25f * scale;
                    if (num267 < 30)
                    {
                        dust61.velocity = vector25 * dust61.velocity.Length();
                    }
                    else
                    {
                        dust61.velocity = vector25 * Main.rand.Next(45, 91) / 10f;
                    }
                    dust61.color = Main.hslToRgb((float)(0.4000000059604645 + Main.rand.NextDouble() * 0.20000000298023224), 0.9f, 0.5f);
                    dust61.color = Color.Lerp(dust61.color, Color.White, 0.3f);
                    dust61.noGravity = true;
                    dust61.scale = 0.7f;
                }
            }
        }
        if (type == 370)
        {
            if (life > 0)
            {
                for (int num270 = 0; (double)num270 < dmg / (double)lifeMax * 100.0; num270++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
            }
            else
            {
                for (int num271 = 0; num271 < 150; num271++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(base.Center - Vector2.UnitX * 20f * direction, velocity, 576, scale);
                Gore.NewGore(base.Center - Vector2.UnitY * 30f, velocity, 574, scale);
                Gore.NewGore(base.Center, velocity, 575, scale);
                Gore.NewGore(base.Center + Vector2.UnitX * 20f * direction, velocity, 573, scale);
                Gore.NewGore(base.Center - Vector2.UnitY * 30f, velocity, 574, scale);
                Gore.NewGore(base.Center, velocity, 575, scale);
            }
        }
        else if (type == 381)
        {
            if (life > 0)
            {
                for (int num272 = 0; (double)num272 < dmg / (double)(lifeMax * 50); num272++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num273 = 0; num273 < 30; num273++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 587, scale);
                Gore.NewGore(position, velocity, 590, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 588, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 589, scale);
            }
        }
        else if (type == 382 || type == 390)
        {
            if (life > 0)
            {
                for (int num274 = 0; (double)num274 < dmg / (double)(lifeMax * 50); num274++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num275 = 0; num275 < 30; num275++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 591, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 592, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 593, scale);
            }
        }
        else if (type == 383)
        {
            if (life > 0)
            {
                for (int num276 = 0; (double)num276 < dmg / (double)(lifeMax * 50); num276++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num277 = 0; num277 < 30; num277++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 594, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 595, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 596, scale);
            }
        }
        else if (type == 384)
        {
            if (life > 0)
            {
                for (int num278 = 0; (double)num278 < dmg / (double)lifeMax * 50.0; num278++)
                {
                    int num279 = Dust.NewDust(position, width, height, 226, -1 * hitDirection, -1f);
                    Main.dust[num279].position = Vector2.Lerp(Main.dust[num279].position, base.Center, 0.25f);
                    Main.dust[num279].scale = 0.5f;
                }
            }
            else
            {
                for (int num280 = 0; num280 < 70; num280++)
                {
                    int num281 = Dust.NewDust(position, width, height, 226, -2.5f * (float)hitDirection, -2.5f);
                    Main.dust[num281].scale = 0.5f;
                }
            }
        }
        else if (type == 385)
        {
            if (life > 0)
            {
                for (int num282 = 0; (double)num282 < dmg / (double)(lifeMax * 50); num282++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num283 = 0; num283 < 30; num283++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 597, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 598, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 599, scale);
            }
        }
        else if (type == 386)
        {
            if (life > 0)
            {
                for (int num284 = 0; (double)num284 < dmg / (double)(lifeMax * 50); num284++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num285 = 0; num285 < 30; num285++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 600, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 601, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 602, scale);
            }
        }
        if (type == 387)
        {
            if (life > 0)
            {
                for (int num286 = 0; (double)num286 < dmg / (double)lifeMax * 20.0; num286++)
                {
                    int num287 = Dust.NewDust(position, width, height, 226, -1 * hitDirection, -1f);
                    Main.dust[num287].position = Vector2.Lerp(Main.dust[num287].position, base.Center, 0.25f);
                    Main.dust[num287].scale = 0.5f;
                }
            }
            else
            {
                for (int num288 = 0; num288 < 30; num288++)
                {
                    int num289 = Dust.NewDust(position, width, height, 226, -1.5f * (float)hitDirection, -1.5f);
                    Main.dust[num289].scale = 0.5f;
                }
                Gore.NewGore(position, velocity, 603, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 603, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 604, scale);
            }
        }
        if (type == 520)
        {
            if (life > 0)
            {
                for (int num290 = 0; (double)num290 < dmg / (double)lifeMax * 20.0; num290++)
                {
                    int num291 = Dust.NewDust(position, width, height, 226, -1 * hitDirection, -1f);
                    Main.dust[num291].position = Vector2.Lerp(Main.dust[num291].position, base.Center, 0.25f);
                    Main.dust[num291].scale = 0.5f;
                }
            }
            else
            {
                for (int num292 = 0; num292 < 30; num292++)
                {
                    int num293 = Dust.NewDust(position, width, height, 226, -1.5f * (float)hitDirection, -1.5f);
                    Main.dust[num293].scale = 0.5f;
                }
                Gore.NewGore(position, velocity, 851, scale);
                Gore.NewGore(position, velocity, 852, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 80f), velocity, 848, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 80f), velocity, 849, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 80f), velocity, 850, scale);
            }
        }
        else if (type == 389)
        {
            if (life > 0)
            {
                for (int num294 = 0; (double)num294 < dmg / (double)(lifeMax * 50); num294++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num295 = 0; num295 < 30; num295++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 904, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 905, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 906, scale);
            }
        }
        else if (type == 388)
        {
            if (life > 0)
            {
                for (int num296 = 0; (double)num296 < dmg / (double)(lifeMax * 50); num296++)
                {
                    int num297 = Dust.NewDust(position, width, height, 226, -1 * hitDirection, -1f);
                    Main.dust[num297].position = Vector2.Lerp(Main.dust[num297].position, base.Center, 0.25f);
                    Main.dust[num297].scale = 0.5f;
                }
            }
            else
            {
                for (int num298 = 0; num298 < 10; num298++)
                {
                    int num299 = Dust.NewDust(position, width, height, 226, -2.5f * (float)hitDirection, -2.5f);
                    Main.dust[num299].scale = 0.5f;
                }
                Vector2 vector26 = velocity;
                if (ai[0] == 3f)
                {
                    vector26 = rotation.ToRotationVector2();
                    if (spriteDirection == 1)
                    {
                        vector26.X *= -1f;
                    }
                    vector26 *= 5f;
                }
                Gore.NewGore(base.Center - new Vector2(10f, 10f), vector26, 605, scale);
                Gore.NewGore(base.Center - new Vector2(10f, 10f), vector26, 606, scale);
            }
        }
        else if (type == 399)
        {
            if (life > 0)
            {
                for (int num300 = 0; (double)num300 < dmg / (double)(lifeMax * 50); num300++)
                {
                    int num301 = Dust.NewDust(position, width, height, 226, -1 * hitDirection, -1f);
                    Main.dust[num301].position = Vector2.Lerp(Main.dust[num301].position, base.Center, 0.25f);
                    Main.dust[num301].scale = 0.5f;
                }
            }
            else
            {
                for (int num302 = 0; num302 < 10; num302++)
                {
                    int num303 = Dust.NewDust(position, width, height, 226, -2.5f * (float)hitDirection, -2.5f);
                    Main.dust[num303].scale = 0.5f;
                }
                Vector2 vector27 = velocity;
                if (ai[0] == 3f)
                {
                    vector27 = rotation.ToRotationVector2();
                    if (spriteDirection == 1)
                    {
                        vector27.X *= -1f;
                    }
                    vector27 *= 5f;
                }
                Gore.NewGore(base.Center - new Vector2(10f, 10f), vector27, 898, scale);
                Gore.NewGore(base.Center - new Vector2(10f, 10f), vector27, 899, scale);
            }
        }
        else if (type == 391)
        {
            if (life > 0)
            {
                for (int num304 = 0; (double)num304 < dmg / (double)(lifeMax * 50); num304++)
                {
                    Dust.NewDust(position, width, height, 227, hitDirection, -1f);
                }
            }
            else
            {
                for (int num305 = 0; num305 < 30; num305++)
                {
                    Dust.NewDust(position, width, height, 227, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position + Vector2.UnitX * width / 2f, velocity, 607, scale);
                Gore.NewGore(position + Vector2.UnitX * width / 2f, velocity, 608, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 609, scale);
            }
        }
        if (type == 392 || type == 394 || type == 393 || type == 395)
        {
            if (life > 0)
            {
                for (int num306 = 0; (double)num306 < dmg / (double)lifeMax * 20.0; num306++)
                {
                    int num307 = Dust.NewDust(position, width, height, 228, -1 * hitDirection, -1f);
                    Main.dust[num307].position = Vector2.Lerp(Main.dust[num307].position, base.Center, 0.25f);
                    Main.dust[num307].scale = 0.5f;
                }
            }
            else
            {
                for (int num308 = 0; num308 < 30; num308++)
                {
                    int num309 = Dust.NewDust(position, width, height, 228, -1.5f * (float)hitDirection, -1.5f);
                    Main.dust[num309].scale = 0.5f;
                }
                Vector2 center2 = base.Center;
                if (type == 395)
                {
                    Gore.NewGore(center2 + new Vector2(-20f, -10f), velocity, 610, scale);
                    Gore.NewGore(center2 + new Vector2(20f, -10f), velocity, 611, scale);
                    Gore.NewGore(center2 + new Vector2(-50f, 0f), velocity, 612, scale);
                    Gore.NewGore(center2 + new Vector2(50f, 0f), velocity, 613, scale);
                    Gore.NewGore(center2 + new Vector2(-60f, 10f), velocity, 614, scale);
                    Gore.NewGore(center2 + new Vector2(0f, 30f), velocity, 615, scale);
                }
                if (type == 393)
                {
                    Gore.NewGore(center2, velocity, 616, scale);
                }
                if (type == 394)
                {
                    Gore.NewGore(center2, velocity, 617, scale);
                }
            }
        }
        else if (type == 482 || type == 483)
        {
            if (life > 0)
            {
                for (int num310 = 0; (double)num310 < dmg / (double)(lifeMax * 50); num310++)
                {
                    Dust.NewDust(position, width, height, 240, hitDirection, -1f);
                }
            }
            else
            {
                for (int num311 = 0; num311 < 30; num311++)
                {
                    Dust.NewDust(position, width, height, 240, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 482)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 718, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 719, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 720, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 40f), velocity, 721, scale);
                }
            }
        }
        else if (type == 631)
        {
            if (life > 0)
            {
                for (int num312 = 0; (double)num312 < dmg / (double)(lifeMax * 50); num312++)
                {
                    Dust.NewDust(position, width, height, 1, hitDirection, -1f);
                }
            }
            else
            {
                for (int num313 = 0; num313 < 30; num313++)
                {
                    Dust.NewDust(position, width, height, 1, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1210, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 1211, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1212, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 40f), velocity, 1213, scale);
            }
        }
        if ((type >= 442 && type <= 448) || type == 539 || type == 592 || type == 593 || type == 601 || type == 605 || type == 627)
        {
            if (life > 0)
            {
                for (int num314 = 0; num314 < 10; num314++)
                {
                    Dust.NewDust(position, width, height, Main.rand.Next(232, 234), hitDirection, -1f);
                }
            }
            else
            {
                for (int num315 = 0; num315 < 20; num315++)
                {
                    Dust.NewDust(position, width, height, Main.rand.Next(232, 234), 2 * hitDirection, -2f);
                }
            }
        }
        if (type == 653 && life <= 0)
        {
            for (int num316 = 0; num316 < 6; num316++)
            {
                int num317 = Dust.NewDust(position, width, height, 174, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num317].noGravity = true;
                    Main.dust[num317].scale = 1.5f * scale;
                }
                else
                {
                    Main.dust[num317].scale = 0.8f * scale;
                }
            }
        }
        if (type == 333 || type == 334 || type == 335 || type == 336)
        {
            Color newColor7 = Color.White;
            if (type == 333)
            {
                newColor7 = new Color(73, 147, 221, 200);
            }
            if (type == 334)
            {
                newColor7 = new Color(24, 146, 79, 200);
            }
            if (type == 335)
            {
                newColor7 = new Color(194, 46, 50, 200);
            }
            if (type == 336)
            {
                newColor7 = new Color(228, 200, 1, 200);
            }
            if (life > 0)
            {
                for (int num318 = 0; (double)num318 < dmg / (double)lifeMax * 100.0; num318++)
                {
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, 150, newColor7);
                }
            }
            else
            {
                for (int num319 = 0; num319 < 50; num319++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, 150, newColor7);
                }
            }
        }
        if (type == 537)
        {
            if (life > 0)
            {
                for (int num320 = 0; (double)num320 < dmg / (double)lifeMax * 100.0; num320++)
                {
                    Dust.NewDust(position, width, height, 32, hitDirection, -1f);
                }
            }
            else
            {
                for (int num321 = 0; num321 < 50; num321++)
                {
                    Dust.NewDust(position, width, height, 32, 2 * hitDirection, -2f);
                }
            }
        }
        if (type == 1 || type == 16 || type == 71 || type == 244 || type == 535)
        {
            if (life > 0)
            {
                for (int num322 = 0; (double)num322 < dmg / (double)lifeMax * 100.0; num322++)
                {
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, alpha, this.color);
                }
            }
            else
            {
                for (int num323 = 0; num323 < 50; num323++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, alpha, this.color);
                }
                if (Main.netMode != 1 && type == 16)
                {
                    int num324 = Main.rand.Next(2) + 2;
                    for (int num325 = 0; num325 < num324; num325++)
                    {
                        int num326 = NewNPC(GetSpawnSource_NPCHurt(), (int)(position.X + (float)(width / 2)), (int)(position.Y + (float)height), 1);
                        Main.npc[num326].SetDefaults(-5);
                        Main.npc[num326].velocity.X = velocity.X * 2f;
                        Main.npc[num326].velocity.Y = velocity.Y;
                        Main.npc[num326].velocity.X += (float)Main.rand.Next(-20, 20) * 0.1f + (float)(num325 * direction) * 0.3f;
                        Main.npc[num326].velocity.Y -= (float)Main.rand.Next(0, 10) * 0.1f + (float)num325;
                        Main.npc[num326].ai[0] = -1000 * Main.rand.Next(3);
                        if (Main.netMode == 2 && num326 < 200)
                        {
                            NetMessage.SendData(23, -1, -1, null, num326);
                        }
                    }
                }
            }
        }
        if (type == 352)
        {
            if (life > 0)
            {
                for (int num327 = 0; (double)num327 < dmg / (double)lifeMax * 100.0; num327++)
                {
                    int num328 = Dust.NewDust(position, width, height, 67, hitDirection, -1f);
                    Main.dust[num328].noGravity = true;
                }
            }
            else
            {
                for (int num329 = 0; num329 < 60; num329++)
                {
                    int num330 = Dust.NewDust(position, width, height, 67, 2 * hitDirection, -2f);
                    Main.dust[num330].noGravity = true;
                }
            }
        }
        if (type >= 305 && type <= 314)
        {
            if (life > 0)
            {
                for (int num331 = 0; (double)num331 < dmg / (double)lifeMax * 100.0; num331++)
                {
                    Dust.NewDust(position, width, height, 194, hitDirection, -1f, 0, default(Color), 1.1f);
                }
            }
            else
            {
                for (int num332 = 0; num332 < 60; num332++)
                {
                    Dust.NewDust(position, width, height, 194, 2 * hitDirection, -2f, 0, default(Color), 1.1f);
                }
                Gore.NewGore(position, velocity, 441, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 442, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 443, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 444, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 445, scale);
            }
        }
        if (type == 327)
        {
            if (life > 0)
            {
                for (int num333 = 0; (double)num333 < dmg / (double)lifeMax * 100.0; num333++)
                {
                    Dust.NewDust(position, width, height, 189, hitDirection, -1f, 0, default(Color), 1.1f);
                }
            }
            else
            {
                for (int num334 = 0; num334 < 60; num334++)
                {
                    Dust.NewDust(position, width, height, 189, 2 * hitDirection, -2f, 0, default(Color), 1.1f);
                }
                for (int num335 = 476; num335 <= 484; num335++)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, num335, scale);
                }
            }
        }
        if (type == 325)
        {
            if (life > 0)
            {
                for (int num336 = 0; (double)num336 < dmg / (double)lifeMax * 100.0; num336++)
                {
                    Dust.NewDust(position, width, height, 191, hitDirection, -1f, 0, default(Color), 1.1f);
                }
            }
            else
            {
                for (int num337 = 0; num337 < 60; num337++)
                {
                    Dust.NewDust(position, width, height, 191, 2 * hitDirection, -2f, 0, default(Color), 1.1f);
                }
                for (int num338 = 469; num338 <= 475; num338++)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, num338, scale);
                }
            }
        }
        if (type == 345 && life <= 0)
        {
            Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, 513, scale);
            Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, 514, scale);
            Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, 514, scale);
            Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, 515, scale);
            Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, 516, scale);
        }
        if (type == 344)
        {
            if (life > 0)
            {
                for (int num339 = 0; (double)num339 < dmg / (double)lifeMax * 100.0; num339++)
                {
                    Dust.NewDust(position, width, height, 196, hitDirection, -1f);
                }
            }
            else
            {
                for (int num340 = 0; num340 < 60; num340++)
                {
                    Dust.NewDust(position, width, height, 196, 2 * hitDirection, -2f);
                }
                for (int num341 = 508; num341 <= 512; num341++)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, num341, scale);
                }
                for (int num342 = 509; num342 <= 512; num342++)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity * 0f, num342, scale);
                }
            }
        }
        if (type == 326)
        {
            if (life > 0)
            {
                for (int num343 = 0; (double)num343 < dmg / (double)lifeMax * 100.0; num343++)
                {
                    Dust.NewDust(position, width, height, 191, hitDirection, -1f, 0, default(Color), 1.1f);
                }
            }
            else
            {
                for (int num344 = 0; num344 < 60; num344++)
                {
                    Dust.NewDust(position, width, height, 191, 2 * hitDirection, -2f, 0, default(Color), 1.1f);
                }
            }
        }
        if (type == 304)
        {
            if (life > 0)
            {
                for (int num345 = 0; (double)num345 < dmg / (double)lifeMax * 100.0; num345++)
                {
                    Dust.NewDust(position, width, height, 189, hitDirection, -1f, 0, default(Color), 1.3f);
                }
            }
            else
            {
                for (int num346 = 0; num346 < 60; num346++)
                {
                    Dust.NewDust(position, width, height, 189, 2 * hitDirection, -2f, 0, default(Color), 1.3f);
                }
            }
        }
        if (type == 302)
        {
            if (life > 0)
            {
                for (int num347 = 0; (double)num347 < dmg / (double)lifeMax * 100.0; num347++)
                {
                    Dust.NewDust(position, width, height, 192, hitDirection, -1f, 100, new Color(100, 100, 100, 100));
                }
            }
            else
            {
                for (int num348 = 0; num348 < 50; num348++)
                {
                    Dust.NewDust(position, width, height, 192, 2 * hitDirection, -2f, 100, new Color(100, 100, 100, 100));
                }
                Gore.NewGore(position, velocity, 440, scale);
            }
        }
        if (type >= 245 && type <= 249)
        {
            if (life > 0)
            {
                for (int num349 = 0; (double)num349 < dmg / (double)lifeMax * 100.0; num349++)
                {
                    Dust.NewDust(position, width, height, 148, hitDirection, -1f);
                }
            }
            else if (type == 246)
            {
                if (Main.netMode != 1)
                {
                    NewNPC(GetSpawnSource_NPCHurt(), (int)base.Center.X, (int)position.Y + height, 249, whoAmI);
                }
            }
            else
            {
                for (int num350 = 0; num350 < 50; num350++)
                {
                    Dust.NewDust(position, width, height, 148, 2 * hitDirection, -2f);
                }
                if (type == 245)
                {
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 368, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 370, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 368, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 370, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 368, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 370, scale);
                    Gore.NewGore(position, velocity, 360, scale);
                    Gore.NewGore(position, velocity, 361, scale);
                    Gore.NewGore(position, velocity, 362, scale);
                    Gore.NewGore(position, velocity, 363, scale);
                    Gore.NewGore(position, velocity, 364, scale);
                    Gore.NewGore(position, velocity, 367, scale);
                    Gore.NewGore(position, velocity, 366, scale);
                }
                else if (type == 249)
                {
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 368, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 370, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 368, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 370, scale);
                    Gore.NewGore(position, velocity, 365, scale);
                    Gore.NewGore(position, velocity, 363, scale);
                    Gore.NewGore(position, velocity, 362, scale);
                }
                else
                {
                    Gore.NewGore(position, velocity, 369, scale);
                    Gore.NewGore(position, velocity, 371, scale);
                    Gore.NewGore(position, velocity, 370, scale);
                }
            }
        }
        if (type == 288 && life <= 0)
        {
            for (int num351 = 0; num351 < 50; num351++)
            {
                int num352 = Dust.NewDust(position, width, height, 180, velocity.X, velocity.Y);
                Dust dust = Main.dust[num352];
                dust.velocity *= 2f;
                Main.dust[num352].noGravity = true;
                Main.dust[num352].scale = 1.4f;
            }
        }
        if (type == 204)
        {
            if (life > 0)
            {
                for (int num353 = 0; (double)num353 < dmg / (double)lifeMax * 100.0; num353++)
                {
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, 100, new Color(149, 208, 104));
                }
            }
            else
            {
                for (int num354 = 0; num354 < 50; num354++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, 100, new Color(149, 208, 104));
                }
            }
        }
        if (type == 225)
        {
            if (life > 0)
            {
                for (int num355 = 0; (double)num355 < dmg / (double)lifeMax * 100.0; num355++)
                {
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, 100, new Color(0, 80, 255, 100));
                }
            }
            else
            {
                for (int num356 = 0; num356 < 50; num356++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, 100, new Color(0, 80, 255, 100));
                }
                Gore.NewGore(position, velocity, 314, scale);
            }
        }
        if (type == 243)
        {
            if (life > 0)
            {
                for (int num357 = 0; (double)num357 < dmg / (double)lifeMax * 150.0; num357++)
                {
                    Dust.NewDust(position, width, height, 161, hitDirection, -1f);
                }
            }
            else
            {
                for (int num358 = 0; num358 < 200; num358++)
                {
                    Dust.NewDust(position, width, height, 161, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 359, scale);
            }
        }
        if ((type == 210 || type == 211) && life <= 0)
        {
            for (int num359 = 0; num359 < 6; num359++)
            {
                int num360 = Dust.NewDust(position, width, height, 150, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num360].noGravity = true;
                    Main.dust[num360].scale = 1.5f;
                }
                else
                {
                    Main.dust[num360].scale = 0.8f;
                }
            }
        }
        if ((type == 355 || type == 358 || type == 654) && life <= 0)
        {
            for (int num361 = 0; num361 < 6; num361++)
            {
                int num362 = Dust.NewDust(position, width, height, 198, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num362].noGravity = true;
                    Main.dust[num362].scale = 1.5f * scale;
                }
                else
                {
                    Main.dust[num362].scale = 0.8f * scale;
                }
            }
        }
        if (type == 677 && life <= 0)
        {
            ParticleOrchestrator.RequestParticleSpawn(clientOnly: true, ParticleOrchestraType.ShimmerArrow, new ParticleOrchestraSettings
            {
                PositionInWorld = base.Center,
                MovementVector = velocity
            });
            for (int num363 = 0; num363 < 6; num363++)
            {
                int num364 = Dust.NewDust(position, width, height, 310, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num364].noGravity = true;
                    Main.dust[num364].scale = 1.5f * scale;
                }
                else
                {
                    Main.dust[num364].scale = 0.8f * scale;
                }
            }
        }
        if (type == 604 && life <= 0)
        {
            for (int num365 = 0; num365 < 6; num365++)
            {
                int num366 = Dust.NewDust(position, width, height, 198, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num366].noGravity = true;
                    Main.dust[num366].scale = 1.5f * scale;
                }
                else
                {
                    Main.dust[num366].scale = 0.8f * scale;
                }
            }
            if (Main.rand.Next(2) == 0)
            {
                Gore.NewGore(position, velocity, 1148);
            }
            if (Main.rand.Next(2) == 0)
            {
                Gore.NewGore(position, velocity, 1149);
            }
        }
        if (type == 669 && life <= 0)
        {
            for (int num367 = 0; num367 < 6; num367++)
            {
                int num368 = Dust.NewDust(position, width, height, 198, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num368].noGravity = true;
                    Main.dust[num368].scale = 1.5f * scale;
                }
                else
                {
                    Main.dust[num368].scale = 0.8f * scale;
                }
            }
            if (Main.rand.Next(2) == 0)
            {
                Gore.NewGore(position, velocity, 1275);
            }
            if (Main.rand.Next(2) == 0)
            {
                Gore.NewGore(position, velocity, 1276);
            }
        }
        if (type == 356 && life <= 0)
        {
            for (int num369 = 0; num369 < 6; num369++)
            {
                int num370 = Dust.NewDust(position, width, height, 199, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num370].noGravity = true;
                    Main.dust[num370].scale = 1.5f * scale;
                }
                else
                {
                    Main.dust[num370].scale = 0.8f * scale;
                }
            }
        }
        if (type >= 484 && type <= 487 && life <= 0)
        {
            for (int num371 = 0; num371 < 6; num371++)
            {
                int num372 = Dust.NewDust(position, width, height, 248 + type - 484, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num372].noGravity = true;
                    Main.dust[num372].scale = 1.2f * scale;
                }
                else
                {
                    Main.dust[num372].scale = 0.7f * scale;
                }
            }
        }
        if (type == 357 && life <= 0)
        {
            for (int num373 = 0; num373 < 6; num373++)
            {
                int num374 = Dust.NewDust(position, width, height, 200, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num374].noGravity = true;
                    Main.dust[num374].scale = 1.2f * scale;
                }
                else
                {
                    Main.dust[num374].scale = 0.7f * scale;
                }
            }
        }
        if (type == 606 && life <= 0)
        {
            for (int num375 = 0; num375 < 6; num375++)
            {
                int num376 = Dust.NewDust(position, width, height, 124, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num376].noGravity = true;
                    Main.dust[num376].scale = 1.2f * scale;
                }
                else
                {
                    Main.dust[num376].scale = 0.7f * scale;
                }
            }
        }
        if (type == 377 && life <= 0)
        {
            for (int num377 = 0; num377 < 6; num377++)
            {
                int num378 = Dust.NewDust(position, width, height, 40, 2 * hitDirection, -2f);
                if (Main.rand.Next(2) == 0)
                {
                    Main.dust[num378].noGravity = true;
                    Main.dust[num378].scale = 1.2f * scale;
                }
                else
                {
                    Main.dust[num378].scale = 0.7f * scale;
                }
            }
        }
        if (type == 374 || type == 375)
        {
            for (int num379 = 0; num379 < 6; num379++)
            {
                int num380 = Dust.NewDust(position, width, height, 165, 0f, 0f, 50, default(Color), 1.5f);
                Dust dust = Main.dust[num380];
                dust.velocity *= 2f;
                Main.dust[num380].noGravity = true;
            }
        }
        if (type == 359)
        {
            if (life <= 0)
            {
                for (int num381 = 0; num381 < 6; num381++)
                {
                    int num382 = Dust.NewDust(position, width, height, 201, 2 * hitDirection, -2f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Main.dust[num382].noGravity = true;
                        Main.dust[num382].scale = 1.2f * scale;
                    }
                    else
                    {
                        Main.dust[num382].scale = 0.7f * scale;
                    }
                }
            }
            Gore.NewGore(position, velocity, 547, scale);
            Gore.NewGore(position, velocity, 548, scale);
        }
        if (type == 360)
        {
            if (life <= 0)
            {
                for (int num383 = 0; num383 < 6; num383++)
                {
                    int num384 = Dust.NewDust(position, width, height, 202, 2 * hitDirection, -2f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Main.dust[num384].noGravity = true;
                        Main.dust[num384].scale = 1.2f * scale;
                    }
                    else
                    {
                        Main.dust[num384].scale = 0.7f * scale;
                    }
                }
            }
            Gore.NewGore(position, velocity, 549, scale);
            Gore.NewGore(position, velocity, 550, scale);
        }
        if (type == 655)
        {
            if (life <= 0)
            {
                for (int num385 = 0; num385 < 6; num385++)
                {
                    int num386 = Dust.NewDust(position, width, height, 174, 2 * hitDirection, -2f);
                    if (Main.rand.Next(2) == 0)
                    {
                        Main.dust[num386].noGravity = true;
                        Main.dust[num386].scale = 1.2f * scale;
                    }
                    else
                    {
                        Main.dust[num386].scale = 0.7f * scale;
                    }
                }
            }
            Gore.NewGore(position, velocity, 1256, scale);
        }
        if (type == 154)
        {
            if (life > 0)
            {
                for (int num387 = 0; (double)num387 < dmg / (double)lifeMax * 50.0; num387++)
                {
                    int num388 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 67, velocity.X, velocity.Y, 90, default(Color), 1.5f);
                    Main.dust[num388].noGravity = true;
                    Dust dust = Main.dust[num388];
                    dust.velocity *= 0.2f;
                }
            }
            else
            {
                for (int num389 = 0; num389 < 50; num389++)
                {
                    int num390 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 67, velocity.X, velocity.Y, 90, default(Color), 1.5f);
                    Main.dust[num390].noGravity = true;
                    Dust dust = Main.dust[num390];
                    dust.velocity *= 0.2f;
                }
                Gore.NewGore(position, velocity, 180, scale);
            }
        }
        if (type == 147 || type == 184)
        {
            if (life > 0)
            {
                for (int num391 = 0; (double)num391 < dmg / (double)lifeMax * 50.0; num391++)
                {
                    int num392 = Dust.NewDust(position, width, height, 76, hitDirection, -1f);
                    Main.dust[num392].noGravity = true;
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, 100, new Color(97, 200, 255, 100));
                }
            }
            else
            {
                for (int num393 = 0; num393 < 30; num393++)
                {
                    int num394 = Dust.NewDust(position, width, height, 76, hitDirection, -2f);
                    Main.dust[num394].noGravity = true;
                    Dust.NewDust(position, width, height, 4, hitDirection, -2f, 100, new Color(97, 200, 255, 100));
                }
            }
        }
        if (type == 143 || type == 144 || type == 145)
        {
            if (life > 0)
            {
                for (int num395 = 0; (double)num395 < dmg / (double)lifeMax * 100.0; num395++)
                {
                    int num396 = Dust.NewDust(position, width, height, 76, hitDirection, -1f);
                    Main.dust[num396].noGravity = true;
                }
            }
            else
            {
                for (int num397 = 0; num397 < 50; num397++)
                {
                    int num398 = Dust.NewDust(position, width, height, 76, hitDirection, -1f);
                    Main.dust[num398].noGravity = true;
                    Dust dust = Main.dust[num398];
                    dust.scale *= 1.2f;
                }
            }
        }
        if (type == 141)
        {
            if (life > 0)
            {
                for (int num399 = 0; (double)num399 < dmg / (double)lifeMax * 100.0; num399++)
                {
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, alpha, new Color(210, 230, 140));
                }
            }
            else
            {
                for (int num400 = 0; num400 < 50; num400++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, alpha, new Color(210, 230, 140));
                }
            }
        }
        if (type == 112 || type == 666)
        {
            for (int num401 = 0; num401 < 20; num401++)
            {
                int num402 = Dust.NewDust(new Vector2(position.X, position.Y + 2f), width, height, 18, 0f, 0f, 100, default(Color), 2f);
                if (Main.rand.Next(2) == 0)
                {
                    Dust dust = Main.dust[num402];
                    dust.scale *= 0.6f;
                }
                else
                {
                    Dust dust = Main.dust[num402];
                    dust.velocity *= 1.4f;
                    Main.dust[num402].noGravity = true;
                }
            }
        }
        if (type == 183)
        {
            if (life > 0)
            {
                for (int num403 = 0; (double)num403 < dmg / (double)lifeMax * 100.0; num403++)
                {
                    Dust.NewDust(position, width, height, 136, 0f, 0f, alpha, this.color);
                }
            }
            else
            {
                for (int num404 = 0; num404 < 50; num404++)
                {
                    int num405 = Dust.NewDust(position, width, height, 136, hitDirection, 0f, alpha, this.color);
                    Dust dust = Main.dust[num405];
                    dust.velocity *= 2f;
                }
            }
        }
        if (type == 81 || type == 121)
        {
            if (life > 0)
            {
                for (int num406 = 0; (double)num406 < dmg / (double)lifeMax * 100.0; num406++)
                {
                    Dust.NewDust(position, width, height, 14, 0f, 0f, alpha, this.color);
                }
            }
            else
            {
                for (int num407 = 0; num407 < 50; num407++)
                {
                    int num408 = Dust.NewDust(position, width, height, 14, hitDirection, 0f, alpha, this.color);
                    Dust dust = Main.dust[num408];
                    dust.velocity *= 2f;
                }
                if (Main.netMode != 1)
                {
                    if (type == 121)
                    {
                        int num409 = NewNPC(GetSpawnSource_NPCHurt(), (int)(position.X + (float)(width / 2)), (int)(position.Y + (float)height), 81);
                        Main.npc[num409].SetDefaults(-2);
                        Main.npc[num409].velocity.X = velocity.X;
                        Main.npc[num409].velocity.Y = velocity.Y;
                        Gore.NewGore(position, velocity, 94, scale);
                        if (Main.netMode == 2 && num409 < 200)
                        {
                            NetMessage.SendData(23, -1, -1, null, num409);
                        }
                    }
                    else if (scale >= 1f)
                    {
                        int num410 = Main.rand.Next(2) + 2;
                        for (int num411 = 0; num411 < num410; num411++)
                        {
                            int num412 = NewNPC(GetSpawnSource_NPCHurt(), (int)(position.X + (float)(width / 2)), (int)(position.Y + (float)height), 1);
                            Main.npc[num412].SetDefaults(-1);
                            Main.npc[num412].velocity.X = velocity.X * 3f;
                            Main.npc[num412].velocity.Y = velocity.Y;
                            Main.npc[num412].velocity.X += (float)Main.rand.Next(-10, 10) * 0.1f + (float)(num411 * direction) * 0.3f;
                            Main.npc[num412].velocity.Y -= (float)Main.rand.Next(0, 10) * 0.1f + (float)num411;
                            Main.npc[num412].ai[1] = num411;
                            if (Main.netMode == 2 && num412 < 200)
                            {
                                NetMessage.SendData(23, -1, -1, null, num412);
                            }
                        }
                    }
                }
            }
        }
        if (type == 120 || type == 137 || type == 138)
        {
            if (life > 0)
            {
                for (int num413 = 0; (double)num413 < dmg / (double)lifeMax * 50.0; num413++)
                {
                    int num414 = Dust.NewDust(position, width, height, 71, 0f, 0f, 200);
                    Dust dust = Main.dust[num414];
                    dust.velocity *= 1.5f;
                }
            }
            else
            {
                for (int num415 = 0; num415 < 50; num415++)
                {
                    int num416 = Dust.NewDust(position, width, height, 71, hitDirection, 0f, 200);
                    Dust dust = Main.dust[num416];
                    dust.velocity *= 1.5f;
                }
            }
        }
        if (type == 122)
        {
            if (life > 0)
            {
                for (int num417 = 0; (double)num417 < dmg / (double)lifeMax * 50.0; num417++)
                {
                    int num418 = Dust.NewDust(position, width, height, 72, 0f, 0f, 200);
                    Dust dust = Main.dust[num418];
                    dust.velocity *= 1.5f;
                }
            }
            else
            {
                for (int num419 = 0; num419 < 50; num419++)
                {
                    int num420 = Dust.NewDust(position, width, height, 72, hitDirection, 0f, 200);
                    Dust dust = Main.dust[num420];
                    dust.velocity *= 1.5f;
                }
            }
        }
        if (type == 75)
        {
            if (life > 0)
            {
                for (int num421 = 0; (double)num421 < dmg / (double)lifeMax * 50.0; num421++)
                {
                    Dust.NewDust(position, width, height, 55, 0f, 0f, 200, this.color);
                }
            }
            else
            {
                for (int num422 = 0; num422 < 50; num422++)
                {
                    int num423 = Dust.NewDust(position, width, height, 55, hitDirection, 0f, 200, this.color);
                    Dust dust = Main.dust[num423];
                    dust.velocity *= 2f;
                }
            }
        }
        if (type == 63 || type == 64 || type == 103)
        {
            Color newColor8 = new Color(50, 120, 255, 100);
            if (type == 64)
            {
                newColor8 = new Color(225, 70, 140, 100);
            }
            if (type == 103)
            {
                newColor8 = new Color(70, 225, 140, 100);
            }
            if (life > 0)
            {
                for (int num424 = 0; (double)num424 < dmg / (double)lifeMax * 50.0; num424++)
                {
                    Dust.NewDust(position, width, height, 4, hitDirection, -1f, 0, newColor8);
                }
            }
            else
            {
                for (int num425 = 0; num425 < 25; num425++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, 0, newColor8);
                }
            }
        }
        else
        {
            if (type == 59 || type == 60 || type == 151)
            {
                if (life > 0)
                {
                    for (int num426 = 0; (double)num426 < dmg / (double)lifeMax * 80.0; num426++)
                    {
                        int num427 = Dust.NewDust(position, width, height, 6, hitDirection * 2, -1f, alpha, default(Color), 1.5f);
                        if (Main.rand.Next(8) != 0)
                        {
                            Main.dust[num427].noGravity = true;
                        }
                    }
                    return;
                }
                for (int num428 = 0; num428 < 40; num428++)
                {
                    int num429 = Dust.NewDust(position, width, height, 6, hitDirection * 2, -1f, alpha, default(Color), 1.5f);
                    if (Main.rand.Next(8) != 0)
                    {
                        Main.dust[num429].noGravity = true;
                    }
                }
                if (Main.expertMode && type == 59 && Main.netMode != 1 && !Main.remixWorld)
                {
                    try
                    {
                        int num430 = (int)(base.Center.X / 16f);
                        int num431 = (int)(base.Center.Y / 16f);
                        if (!WorldGen.SolidTile(num430, num431) && Main.tile[num430, num431].liquid == 0)
                        {
                            Main.tile[num430, num431].liquid = (byte)Main.rand.Next(50, 150);
                            Main.tile[num430, num431].lava(lava: true);
                            Main.tile[num430, num431].honey(honey: false);
                            WorldGen.SquareTileFrame(num430, num431);
                        }
                    }
                    catch
                    {
                    }
                }
                if ((type != 151 && type != 60) || Main.netMode == 1 || !Main.remixWorld || !Main.getGoodWorld)
                {
                    return;
                }
                try
                {
                    int num432 = (int)(base.Center.X / 16f);
                    int num433 = (int)(base.Center.Y / 16f);
                    if (!WorldGen.SolidTile(num432, num433) && Main.tile[num432, num433].liquid == 0)
                    {
                        Main.tile[num432, num433].liquid = (byte)Main.rand.Next(50, 150);
                        Main.tile[num432, num433].lava(lava: true);
                        Main.tile[num432, num433].honey(honey: false);
                        WorldGen.SquareTileFrame(num432, num433);
                    }
                    return;
                }
                catch
                {
                    return;
                }
            }
            if (type == 50)
            {
                if (life > 0)
                {
                    for (int num434 = 0; (double)num434 < dmg / (double)lifeMax * 300.0; num434++)
                    {
                        Dust.NewDust(position, width, height, 4, hitDirection, -1f, 175, new Color(0, 80, 255, 100));
                    }
                    return;
                }
                for (int num435 = 0; num435 < 200; num435++)
                {
                    Dust.NewDust(position, width, height, 4, 2 * hitDirection, -2f, 175, new Color(0, 80, 255, 100));
                }
                Gore.NewGore(base.Center + new Vector2(-40f, -height / 2), velocity, 734);
                if (Main.netMode == 1)
                {
                    return;
                }
                int num436 = Main.rand.Next(4) + 4;
                for (int num437 = 0; num437 < num436; num437++)
                {
                    int x = (int)(position.X + (float)Main.rand.Next(width - 32));
                    int y = (int)(position.Y + (float)Main.rand.Next(height - 32));
                    int num438 = NewNPC(GetSpawnSource_NPCHurt(), x, y, 1, whoAmI + 1);
                    Main.npc[num438].SetDefaults(1);
                    Main.npc[num438].velocity.X = (float)Main.rand.Next(-15, 16) * 0.1f;
                    Main.npc[num438].velocity.Y = (float)Main.rand.Next(-30, 1) * 0.1f;
                    Main.npc[num438].ai[0] = -1000 * Main.rand.Next(3);
                    Main.npc[num438].ai[1] = 0f;
                    if (Main.netMode == 2 && num438 < 200)
                    {
                        NetMessage.SendData(23, -1, -1, null, num438);
                    }
                }
            }
            else if (type == 153)
            {
                if (life > 0)
                {
                    for (int num439 = 0; (double)num439 < dmg / (double)lifeMax * 30.0; num439++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num440 = 0; num440 < 15; num440++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 177);
                Gore.NewGore(position, velocity, 178);
                Gore.NewGore(position, velocity, 179);
                Gore.NewGore(position, velocity, 179);
            }
            else if (type == 177)
            {
                if (life > 0)
                {
                    for (int num441 = 0; (double)num441 < dmg / (double)lifeMax * 30.0; num441++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num442 = 0; num442 < 15; num442++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 234);
                Gore.NewGore(position, velocity, 235);
                Gore.NewGore(position, velocity, 236);
                Gore.NewGore(position, velocity, 236);
            }
            else if (type >= 494 && type <= 495)
            {
                if (life > 0)
                {
                    for (int num443 = 0; (double)num443 < dmg / (double)lifeMax * 30.0; num443++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num444 = 0; num444 < 15; num444++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                int num445 = (type - 494) * 2;
                Gore.NewGore(position, velocity, 736 + num445);
                Gore.NewGore(position, velocity, 735 + num445);
            }
            else if (type >= 496 && type <= 497)
            {
                if (life > 0)
                {
                    for (int num446 = 0; (double)num446 < dmg / (double)lifeMax * 30.0; num446++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num447 = 0; num447 < 15; num447++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                int num448 = type - 496;
                Gore.NewGore(position, velocity, 739 + num448);
            }
            else if (type >= 498 && type <= 506)
            {
                if (life > 0)
                {
                    for (int num449 = 0; (double)num449 < dmg / (double)lifeMax * 30.0; num449++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num450 = 0; num450 < 15; num450++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                int num451 = type - 498;
                Gore.NewGore(position, velocity, 750 + num451);
                Gore.NewGore(new Vector2(position.X, position.Y + 16f), velocity, 741 + num451);
                Gore.NewGore(new Vector2(position.X, position.Y + 18f), velocity, 759 + num451);
            }
            else if (type == 49 || type == 51 || type == 93 || type == 150 || type == 152 || type == 226)
            {
                if (life > 0)
                {
                    for (int num452 = 0; (double)num452 < dmg / (double)lifeMax * 30.0; num452++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num453 = 0; num453 < 15; num453++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 51)
                {
                    Gore.NewGore(position, velocity, 83);
                }
                else if (type == 93)
                {
                    Gore.NewGore(position, velocity, 107);
                }
                else if (type == 150)
                {
                    Gore.NewGore(position, velocity, 164);
                    Gore.NewGore(position, velocity, 165);
                }
                else if (type == 152)
                {
                    Gore.NewGore(position, velocity, 175);
                    Gore.NewGore(position, velocity, 176);
                    Gore.NewGore(position, velocity, 176);
                }
                else if (type == 226)
                {
                    Gore.NewGore(position, velocity, 317);
                    Gore.NewGore(position, velocity, 318);
                    Gore.NewGore(position, velocity, 318);
                    Gore.NewGore(position, velocity, 319);
                }
                else
                {
                    Gore.NewGore(position, velocity, 82);
                }
            }
            else if (type == 611)
            {
                if (life > 0)
                {
                    for (int num454 = 0; (double)num454 < dmg / (double)lifeMax * 30.0; num454++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num455 = 0; num455 < 15; num455++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 1164);
                Gore.NewGore(position, velocity, 1164);
                Gore.NewGore(position, velocity, 1165);
            }
            else if (type == 624)
            {
                if (life > 0)
                {
                    for (int num456 = 0; (double)num456 < dmg / (double)lifeMax * 20.0; num456++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num457 = 0; num457 < 10; num457++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 1190);
                Gore.NewGore(position, velocity, 1191);
                Gore.NewGore(position, velocity, 1192);
                Gore.NewGore(position, velocity, 1193);
            }
            else if (type == 628)
            {
                if (life > 0)
                {
                    for (int num458 = 0; (double)num458 < dmg / (double)lifeMax * 20.0; num458++)
                    {
                        Dust.NewDust(position, width, height, 3, hitDirection, -1f);
                    }
                    return;
                }
                for (int num459 = 0; num459 < 10; num459++)
                {
                    Dust.NewDust(position, width, height, 3, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 1205);
                Gore.NewGore(position, velocity, 1206);
                Gore.NewGore(position, velocity, 1206);
                Gore.NewGore(position, velocity, 1207);
            }
            else if (type >= 646 && type <= 652)
            {
                int num460 = 138;
                if (type < 652)
                {
                    num460 = 86 + (type - 646);
                }
                if (life > 0)
                {
                    for (int num461 = 0; (double)num461 < dmg / (double)lifeMax * 20.0; num461++)
                    {
                        Dust.NewDust(position, width, height, num460, hitDirection, -1f);
                    }
                    return;
                }
                for (int num462 = 0; num462 < 10; num462++)
                {
                    Dust.NewDust(position, width, height, num460, 2 * hitDirection, -2f);
                }
                int num463 = (type - 646) * 2;
                Gore.NewGore(position, velocity, 1234 + num463);
                Gore.NewGore(position, velocity, 1235 + num463);
            }
            else if (type >= 639 && type <= 645)
            {
                int num464 = 138;
                if (type < 645)
                {
                    num464 = 86 + (type - 639);
                }
                if (life > 0)
                {
                    for (int num465 = 0; (double)num465 < dmg / (double)lifeMax * 20.0; num465++)
                    {
                        Dust.NewDust(position, width, height, num464, hitDirection, -1f);
                    }
                    return;
                }
                for (int num466 = 0; num466 < 10; num466++)
                {
                    Dust.NewDust(position, width, height, num464, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 1227 + (type - 639));
            }
            else if (type == 46 || type == 55 || type == 67 || type == 74 || type == 102 || type == 224 || type == 230 || type == 297 || type == 298 || type == 299 || type == 300 || type == 303 || type == 337 || type == 538 || type == 540 || type == 587 || type == 610 || type == 614 || type == 616 || type == 617 || type == 625 || type == 626 || type == 627 || type == 615 || type == 671 || type == 672 || type == 673 || type == 674 || type == 675)
            {
                if (life > 0)
                {
                    for (int num467 = 0; (double)num467 < dmg / (double)lifeMax * 20.0; num467++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num468 = 0; num468 < 10; num468++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 46 || type == 303 || type == 337 || type == 540)
                {
                    Gore.NewGore(position, velocity, 76);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 77);
                    if (type == 303)
                    {
                        for (int num469 = 0; num469 < 10; num469++)
                        {
                            Dust.NewDust(position, width, height, 193, 2 * hitDirection, -2f);
                        }
                    }
                    if (type == 540)
                    {
                        Gore.NewGore(position, velocity, 926);
                    }
                }
                else if (type == 67)
                {
                    Gore.NewGore(position, velocity, 95);
                    Gore.NewGore(position, velocity, 95);
                    Gore.NewGore(position, velocity, 96);
                }
                else if (type == 55 || type == 230)
                {
                    Gore.NewGore(position, velocity, 553);
                    Gore.NewGore(position, velocity, 554);
                }
                else if (type == 615)
                {
                    Gore.NewGore(position, velocity, 1198);
                    Gore.NewGore(position, velocity, 1199);
                    Gore.NewGore(position, velocity, 1200);
                    Gore.NewGore(position, velocity, 1200);
                }
                else if (type == 74)
                {
                    Gore.NewGore(position, velocity, 100);
                }
                else if (type == 297)
                {
                    Gore.NewGore(position, velocity, 431);
                }
                else if (type == 298)
                {
                    Gore.NewGore(position, velocity, 432);
                }
                else if (type == 671)
                {
                    Gore.NewGore(position, velocity, 1277);
                    Gore.NewGore(base.Center + new Vector2(4f, 0f), velocity, 1279);
                    Gore.NewGore(base.Center + new Vector2(-4f, 0f), velocity, 1279);
                }
                else if (type == 672)
                {
                    Gore.NewGore(position, velocity, 1280);
                    Gore.NewGore(base.Center + new Vector2(4f, 0f), velocity, 1281);
                    Gore.NewGore(base.Center + new Vector2(-4f, 0f), velocity, 1281);
                }
                else if (type == 673)
                {
                    Gore.NewGore(position, velocity, 1282);
                    Gore.NewGore(base.Center + new Vector2(4f, 0f), velocity, 1283);
                    Gore.NewGore(base.Center + new Vector2(-4f, 0f), velocity, 1283);
                }
                else if (type == 674)
                {
                    Gore.NewGore(position, velocity, 1284);
                    Gore.NewGore(base.Center + new Vector2(4f, 0f), velocity, 1285);
                    Gore.NewGore(base.Center + new Vector2(-4f, 0f), velocity, 1285);
                }
                else if (type == 675)
                {
                    Gore.NewGore(position, velocity, 1286);
                    Gore.NewGore(base.Center + new Vector2(4f, 0f), velocity, 1287);
                    Gore.NewGore(base.Center + new Vector2(-4f, 0f), velocity, 1287);
                }
                else if (type == 299)
                {
                    Gore.NewGore(position, velocity, 433);
                }
                else if (type == 538)
                {
                    Gore.NewGore(position, velocity, 897);
                }
                else if (type == 300)
                {
                    Gore.NewGore(position, velocity, 434);
                }
                else if (type == 610)
                {
                    Gore.NewGore(position, velocity, 1163);
                }
                else if (type == 626)
                {
                    Gore.NewGore(position, velocity, 1197);
                }
                else if (type == 102)
                {
                    Gore.NewGore(position, velocity, 116);
                }
                else if (type == 224)
                {
                    Gore.NewGore(position, velocity, 312);
                    Gore.NewGore(position, velocity, 313);
                }
                else if (type == 587)
                {
                    for (int num470 = 0; num470 < 50; num470++)
                    {
                        Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                    }
                    Gore.NewGore(position, velocity, 1104);
                    Gore.NewGore(position, velocity, 1105);
                }
                else if (type == 616)
                {
                    Gore.NewGore(position, velocity, 1166);
                    Gore.NewGore(position, velocity, 1167);
                    Gore.NewGore(position, velocity, 1168);
                    Gore.NewGore(position, velocity, 1168);
                }
                else if (type == 617)
                {
                    Gore.NewGore(position, velocity, 1169);
                    Gore.NewGore(position, velocity, 1170);
                    Gore.NewGore(position, velocity, 1171);
                    Gore.NewGore(position, velocity, 1171);
                }
                else if (type == 625)
                {
                    Gore.NewGore(position, velocity, 1194);
                    Gore.NewGore(position, velocity, 1195);
                    Gore.NewGore(position, velocity, 1196);
                    Gore.NewGore(position, velocity, 1196);
                }
            }
            else if (type == 148 || type == 149 || type == 168 || type == 470)
            {
                if (life > 0)
                {
                    for (int num471 = 0; (double)num471 < dmg / (double)lifeMax * 20.0; num471++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num472 = 0; num472 < 10; num472++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 148)
                {
                    Gore.NewGore(position, velocity, 160);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 161);
                }
                else if (type == 149)
                {
                    Gore.NewGore(position, velocity, 162);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 163);
                }
                else if (type == 168)
                {
                    Gore.NewGore(position, velocity, 215);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 216);
                }
                else if (type == 470)
                {
                    Gore.NewGore(position, velocity, 673);
                    Gore.NewGore(position, velocity, 672);
                    Gore.NewGore(position, velocity, 674);
                }
            }
            else if (type == 361)
            {
                if (life > 0)
                {
                    for (int num473 = 0; (double)num473 < dmg / (double)lifeMax * 20.0; num473++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num474 = 0; num474 < 10; num474++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 551);
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, 552);
            }
            else if (type == 687)
            {
                if (life > 0)
                {
                    for (int num475 = 0; (double)num475 < dmg / (double)lifeMax * 20.0; num475++)
                    {
                        Dust.NewDust(position, width, height, 16, hitDirection, -1f);
                    }
                }
                else
                {
                    Vector2 vector28 = base.Center - new Vector2(20f);
                    Utils.PoofOfSmoke(vector28);
                }
            }
            else if (type == 685)
            {
                if (life > 0)
                {
                    for (int num476 = 0; (double)num476 < dmg / (double)lifeMax * 20.0; num476++)
                    {
                        Dust.NewDust(position, width, height, 0, hitDirection, -1f);
                    }
                }
                else
                {
                    Vector2 vector29 = base.Center - new Vector2(20f);
                    Utils.PoofOfSmoke(vector29);
                }
            }
            else if (type == 607)
            {
                if (life > 0)
                {
                    for (int num477 = 0; (double)num477 < dmg / (double)lifeMax * 20.0; num477++)
                    {
                        Dust.NewDust(position, width, height, 45, hitDirection, -1f);
                    }
                    return;
                }
                for (int num478 = 0; num478 < 10; num478++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 1152);
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1153);
            }
            else if (type == 366 || type == 367)
            {
                if (life > 0)
                {
                    for (int num479 = 0; (double)num479 < dmg / (double)lifeMax * 20.0; num479++)
                    {
                        Dust.NewDust(position, width, height, 203, hitDirection, -1f);
                    }
                    return;
                }
                for (int num480 = 0; num480 < 10; num480++)
                {
                    Dust.NewDust(position, width, height, 203, 2 * hitDirection, -2f);
                }
                if (type == 366)
                {
                    Gore.NewGore(position, velocity, 561);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 562);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 563);
                }
                else
                {
                    Gore.NewGore(position, velocity, 564);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 565);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 566);
                }
            }
            else if (type >= 362 && type <= 365)
            {
                if (life > 0)
                {
                    for (int num481 = 0; (double)num481 < dmg / (double)lifeMax * 20.0; num481++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num482 = 0; num482 < 10; num482++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 362 || type == 363)
                {
                    Gore.NewGore(position, velocity, 555);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 556);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 557);
                }
                else
                {
                    Gore.NewGore(position, velocity, 558);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 559);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 560);
                }
            }
            else if (type == 602 || type == 603)
            {
                if (life > 0)
                {
                    for (int num483 = 0; (double)num483 < dmg / (double)lifeMax * 20.0; num483++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num484 = 0; num484 < 10; num484++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 602 || type == 603)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1150);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1151);
                }
            }
            else if (type == 608 || type == 609)
            {
                if (life > 0)
                {
                    for (int num485 = 0; (double)num485 < dmg / (double)lifeMax * 20.0; num485++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num486 = 0; num486 < 10; num486++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 608 || type == 609)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1154);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1155);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 1156);
                }
            }
            else if (type == 348 || type == 349)
            {
                if (life > 0)
                {
                    for (int num487 = 0; (double)num487 < dmg / (double)lifeMax * 20.0; num487++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num488 = 0; num488 < 10; num488++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 528);
                Gore.NewGore(position, velocity, 529);
                Gore.NewGore(position, velocity, 530);
                Gore.NewGore(position, velocity, 531);
                Gore.NewGore(position, velocity, 532);
            }
            else if (type == 351)
            {
                if (life > 0)
                {
                    for (int num489 = 0; (double)num489 < dmg / (double)lifeMax * 20.0; num489++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num490 = 0; num490 < 10; num490++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 538);
                Gore.NewGore(position, velocity, 539);
                Gore.NewGore(position, velocity, 540);
                Gore.NewGore(position, velocity, 541);
                Gore.NewGore(position, velocity, 542);
            }
            else if (type == 350)
            {
                if (life > 0)
                {
                    for (int num491 = 0; (double)num491 < dmg / (double)lifeMax * 20.0; num491++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num492 = 0; num492 < 10; num492++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 533);
                Gore.NewGore(position, velocity, 534);
                Gore.NewGore(position, velocity, 535);
                Gore.NewGore(position, velocity, 536);
            }
            else if (type == 47 || type == 57 || type == 58 || type == 464 || type == 465)
            {
                if (life > 0)
                {
                    for (int num493 = 0; (double)num493 < dmg / (double)lifeMax * 20.0; num493++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num494 = 0; num494 < 10; num494++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 57)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 84);
                }
                else if (type == 58)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 85);
                }
                else if (type == 464)
                {
                    Gore.NewGore(position, velocity, 668);
                    Gore.NewGore(position, velocity, 669);
                }
                else if (type == 465)
                {
                    Gore.NewGore(position, velocity, 670);
                    Gore.NewGore(position, velocity, 671);
                }
                else
                {
                    Gore.NewGore(position, velocity, 78);
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 79);
                }
            }
            else if (type == 173 || type == 174 || type == 181 || type == 182 || type == 268)
            {
                if (life > 0)
                {
                    for (int num495 = 0; (double)num495 < dmg / (double)lifeMax * 100.0; num495++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f, alpha);
                    }
                    return;
                }
                for (int num496 = 0; num496 < 50; num496++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f, alpha);
                }
                if (type == 173)
                {
                    Gore.NewGore(position, velocity, 223);
                    Gore.NewGore(position, velocity, 224);
                }
                else if (type == 174)
                {
                    Gore.NewGore(position, velocity, 225);
                    Gore.NewGore(position, velocity, 226);
                }
                else if (type == 181)
                {
                    Gore.NewGore(position, velocity, 237);
                }
                else if (type == 182)
                {
                    Gore.NewGore(position, velocity, 238);
                    Gore.NewGore(position, velocity, 239);
                }
                else if (type == 268)
                {
                    Gore.NewGore(position, velocity, 403);
                    Gore.NewGore(position, velocity, 404);
                    Gore.NewGore(position, velocity, 405);
                }
            }
            else if (type == 2 || type == 190 || type == 191 || type == 192 || type == 193 || type == 194 || type == 317 || type == 318)
            {
                if (life > 0)
                {
                    for (int num497 = 0; (double)num497 < dmg / (double)lifeMax * 100.0; num497++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num498 = 0; num498 < 50; num498++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 190)
                {
                    Gore.NewGore(position, velocity, 249, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 2, scale);
                }
                else if (type == 191)
                {
                    Gore.NewGore(position, velocity, 248, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 2, scale);
                }
                else if (type == 192)
                {
                    Gore.NewGore(position, velocity, 247, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 2, scale);
                }
                else if (type == 193)
                {
                    Gore.NewGore(position, velocity, 252, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 253, scale);
                }
                else if (type == 194)
                {
                    Gore.NewGore(position, velocity, 250, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 251, scale);
                }
                else if (type == 317)
                {
                    Gore.NewGore(position, velocity, 447, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 448, scale);
                }
                else if (type == 318)
                {
                    Gore.NewGore(position, velocity, 449, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 450, scale);
                }
                else
                {
                    Gore.NewGore(position, velocity, 1, scale);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 2, scale);
                }
            }
            else if (type == 157)
            {
                if (life > 0)
                {
                    for (int num499 = 0; (double)num499 < dmg / (double)lifeMax * 100.0; num499++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num500 = 0; num500 < 50; num500++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 186);
                Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 187);
            }
            else if (type == 133)
            {
                if (life > 0)
                {
                    for (int num501 = 0; (double)num501 < dmg / (double)lifeMax * 100.0; num501++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    if ((float)life < (float)lifeMax * 0.5f && localAI[0] == 0f)
                    {
                        localAI[0] = 1f;
                        Gore.NewGore(position, velocity, 1);
                    }
                }
                else
                {
                    for (int num502 = 0; num502 < 50; num502++)
                    {
                        Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                    }
                    Gore.NewGore(position, velocity, 155);
                    Gore.NewGore(new Vector2(position.X, position.Y + 14f), velocity, 155);
                }
            }
            else if (type == 69 || type == 581 || type == 580 || type == 508 || type == 509 || type == 582)
            {
                float num503 = 100f;
                float num504 = 50f;
                if (type == 582)
                {
                    num503 = 30f;
                    num504 = 10f;
                }
                if (life > 0)
                {
                    for (int num505 = 0; (double)num505 < dmg / (double)lifeMax * (double)num503; num505++)
                    {
                        Dust.NewDust(position, width, height, 250, hitDirection, -1f);
                    }
                    return;
                }
                for (int num506 = 0; (float)num506 < num504; num506++)
                {
                    Dust.NewDust(position, width, height, 250, 2 * hitDirection, -2f);
                }
                if (type == 69)
                {
                    Gore.NewGore(position, velocity, 97);
                    Gore.NewGore(position, velocity, 98);
                }
                else if (type == 580)
                {
                    Gore.NewGore(position, velocity, 1094);
                    Gore.NewGore(position, velocity, 1095);
                    Gore.NewGore(position, velocity, 1096);
                    Gore.NewGore(position, velocity, 1097);
                }
                else if (type == 581)
                {
                    Gore.NewGore(position, velocity, 1098);
                    Gore.NewGore(position, velocity, 1099);
                    Gore.NewGore(position, velocity, 1100);
                    Gore.NewGore(position, velocity, 1101);
                    Gore.NewGore(position, velocity, 1101);
                }
                else if (type == 508)
                {
                    Gore.NewGore(position, velocity, 811);
                    Gore.NewGore(position, velocity, 812);
                    Gore.NewGore(position, velocity, 813);
                    Gore.NewGore(position, velocity, 814);
                }
                else if (type == 509)
                {
                    Gore.NewGore(position, velocity, 815);
                    Gore.NewGore(position, velocity, 816);
                    Gore.NewGore(position, velocity, 817);
                    Gore.NewGore(position, velocity, 818);
                    Gore.NewGore(position, velocity, 818);
                }
                else if (type == 582)
                {
                    Gore.NewGore(position, velocity, 1102);
                    Gore.NewGore(position, velocity, 1103);
                }
            }
            else if (type == 61)
            {
                if (life > 0)
                {
                    for (int num507 = 0; (double)num507 < dmg / (double)lifeMax * 100.0; num507++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num508 = 0; num508 < 50; num508++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 86);
                Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 87);
                Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 88);
            }
            else if (type == 301)
            {
                if (life > 0)
                {
                    for (int num509 = 0; (double)num509 < dmg / (double)lifeMax * 100.0; num509++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num510 = 0; num510 < 50; num510++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 438);
                Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity, 439);
            }
            else if (type == 252)
            {
                if (life > 0)
                {
                    for (int num511 = 0; (double)num511 < dmg / (double)lifeMax * 100.0; num511++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num512 = 0; num512 < 50; num512++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 373);
                Gore.NewGore(position, velocity, 374);
            }
            else if (type == 489 || type == 586)
            {
                if (life > 0)
                {
                    for (int num513 = 0; (double)num513 < dmg / (double)lifeMax * 100.0; num513++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num514 = 0; num514 < 50; num514++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 489)
                {
                    Gore.NewGore(position, velocity, 722, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 723, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 723, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 724, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 724, scale);
                }
                if (type == 586)
                {
                    Gore.NewGore(position, velocity, 1106, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1107, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1107, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 1108, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 1108, scale);
                }
            }
            else if (type == 534)
            {
                if (life > 0)
                {
                    for (int num515 = 0; (double)num515 < dmg / (double)lifeMax * 100.0; num515++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num516 = 0; num516 < 50; num516++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 894, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 895, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 895, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 896, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 896, scale);
            }
            else if (type == 490)
            {
                if (life > 0)
                {
                    for (int num517 = 0; (double)num517 < dmg / (double)lifeMax * 100.0; num517++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num518 = 0; num518 < 50; num518++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 725, scale);
                Gore.NewGore(position, velocity, 726, scale);
                Gore.NewGore(position, velocity, 727, scale);
                Gore.NewGore(position, velocity, 725 + Main.rand.Next(3), scale);
                Gore.NewGore(position, velocity, 725 + Main.rand.Next(3), scale);
            }
            else if (type == 65 || (type >= 542 && type <= 545))
            {
                if (life > 0)
                {
                    for (int num519 = 0; (double)num519 < dmg / (double)lifeMax * 150.0; num519++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num520 = 0; num520 < 75; num520++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                if (type == 65)
                {
                    Gore.NewGore(position, velocity * 0.8f, 89);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 90);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 91);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 92);
                }
                if (type == 542)
                {
                    Gore.NewGore(position, velocity * 0.8f, 944);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 945);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 946);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 947);
                }
                if (type == 543)
                {
                    Gore.NewGore(position, velocity * 0.8f, 948);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 949);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 950);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 951);
                }
                if (type == 544)
                {
                    Gore.NewGore(position, velocity * 0.8f, 952);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 953);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 954);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 955);
                }
                if (type == 545)
                {
                    Gore.NewGore(position, velocity * 0.8f, 956);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 957);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 958);
                    Gore.NewGore(new Vector2(position.X + 14f, position.Y), velocity * 0.8f, 959);
                }
            }
            else if (type == 195 || type == 196)
            {
                if (life > 0)
                {
                    for (int num521 = 0; (double)num521 < dmg / (double)lifeMax * 150.0; num521++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num522 = 0; num522 < 75; num522++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 254, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 255, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 255, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 256, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 256, scale);
            }
            else if (type == 198 || type == 199)
            {
                if (life > 0)
                {
                    for (int num523 = 0; (double)num523 < dmg / (double)lifeMax * 150.0; num523++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num524 = 0; num524 < 75; num524++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 258, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 259, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 259, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 260, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 260, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 261, scale);
            }
            else if (type == 206)
            {
                if (life > 0)
                {
                    for (int num525 = 0; (double)num525 < dmg / (double)lifeMax * 150.0; num525++)
                    {
                        Dust.NewDust(position, width, height, 137, hitDirection, -1f);
                    }
                    return;
                }
                for (int num526 = 0; num526 < 75; num526++)
                {
                    Dust.NewDust(position, width, height, 137, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 273, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 274, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 274, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 275, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 275, scale);
            }
            else if (type == 342)
            {
                if (life > 0)
                {
                    for (int num527 = 0; (double)num527 < dmg / (double)lifeMax * 100.0; num527++)
                    {
                        Dust.NewDust(position, width, height, 0, hitDirection, -1f);
                    }
                    return;
                }
                for (int num528 = 0; num528 < 50; num528++)
                {
                    Dust.NewDust(position, width, height, 0, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 500, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 501, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 501, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 502, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 502, scale);
            }
            else if (type >= 338 && type <= 340)
            {
                if (life > 0)
                {
                    for (int num529 = 0; (double)num529 < dmg / (double)lifeMax * 100.0; num529++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num530 = 0; num530 < 50; num530++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 338)
                {
                    Gore.NewGore(position, velocity, 494, scale);
                }
                if (type == 339)
                {
                    Gore.NewGore(position, velocity, 495, scale);
                }
                if (type == 340)
                {
                    Gore.NewGore(position, velocity, 496, scale);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 497, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 498, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 499, scale);
            }
            else if (type == 343)
            {
                if (life > 0)
                {
                    for (int num531 = 0; (double)num531 < dmg / (double)lifeMax * 100.0; num531++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num532 = 0; num532 < 50; num532++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 503, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 504, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 505, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 506, scale);
            }
            else if ((type >= 430 && type <= 436) || type == 590 || type == 591 || type == 3 || type == 52 || type == 53 || type == 536 || type == 104 || type == 109 || type == 331 || type == 332 || type == 132 || type == 161 || type == 162 || type == 186 || type == 187 || type == 188 || type == 189 || type == 200 || type == 223 || type == 251 || type == 319 || type == 320 || type == 321 || type == 632)
            {
                if (life > 0)
                {
                    for (int num533 = 0; (double)num533 < dmg / (double)lifeMax * 100.0; num533++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    if (type == 186 && Main.rand.Next(5) == 0)
                    {
                        Gore.NewGore(position, velocity, 242);
                    }
                    if (type == 632 && Main.rand.Next(5) == 0)
                    {
                        Gore.NewGore(position, velocity, 1217);
                    }
                    if (type == 187)
                    {
                        for (int num534 = 0; (double)num534 < dmg / (double)lifeMax * 200.0; num534++)
                        {
                            Dust.NewDust(position, width, 24, 4, hitDirection, -1f, 125, new Color(0, 80, 255, 100));
                        }
                    }
                    if ((type == 590 || type == 591) && !wet)
                    {
                        for (int num535 = 0; num535 < 3; num535++)
                        {
                            Dust.NewDust(position, width, 24, 6, hitDirection, -1f, 125, new Color(0, 80, 255, 100));
                        }
                    }
                    return;
                }
                for (int num536 = 0; num536 < 50; num536++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 187 || type == 433)
                {
                    for (int num537 = 0; num537 < 25; num537++)
                    {
                        Dust.NewDust(position, width, 24, 4, hitDirection, -1f, 125, new Color(0, 80, 255, 100));
                    }
                }
                if (type == 104)
                {
                    Gore.NewGore(position, velocity, 117, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 118, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 118, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 119, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 119, scale);
                    return;
                }
                if (type == 632)
                {
                    Gore.NewGore(position, velocity, 1214, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1215, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 1215, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 1216, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 1216, scale);
                    if (Main.netMode != 1)
                    {
                        int num538 = Main.rand.Next(2) + 2;
                        for (int num539 = 0; num539 < num538; num539++)
                        {
                            Vector2 vector30 = new Vector2((float)Main.rand.Next(-10, 10) * 0.2f, -3.5f - (float)Main.rand.Next(5, 10) * 0.3f - (float)num539 * 0.5f);
                            int num540 = NewNPC(GetSpawnSource_NPCHurt(), (int)(position.X + (float)(width / 2)), (int)position.Y + Main.rand.Next(height / 2) + 10, 606);
                            Main.npc[num540].velocity = vector30;
                            Main.npc[num540].netUpdate = true;
                        }
                    }
                    return;
                }
                if (type == 331)
                {
                    Gore.NewGore(position, velocity, 488, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 489, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 489, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 490, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 490, scale);
                    return;
                }
                if (type == 332)
                {
                    Gore.NewGore(position, velocity, 491, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 492, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 492, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 493, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 493, scale);
                    return;
                }
                if (type == 109)
                {
                    Gore.NewGore(position, velocity, 121, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 122, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 122, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 123, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 123, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 46f), velocity, 120, scale);
                    return;
                }
                if (type == 161 || type == 431)
                {
                    Gore.NewGore(position, velocity, 191, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 192, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 192, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 193, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 193, scale);
                    return;
                }
                if (type == 162)
                {
                    Gore.NewGore(position, velocity, 194, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 195, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 195, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 196, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 196, scale);
                    return;
                }
                if (type == 188 || type == 434)
                {
                    Gore.NewGore(position, velocity, 243, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 244, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 244, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 245, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 245, scale);
                    return;
                }
                if (type == 200 || type == 436)
                {
                    Gore.NewGore(position, velocity, 262, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 263, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 263, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 264, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 264, scale);
                    return;
                }
                if (type == 319)
                {
                    Gore.NewGore(position, velocity, 451, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 453, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 453, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 452, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 452, scale);
                    return;
                }
                if (type == 320)
                {
                    Gore.NewGore(position, velocity, 454, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 455, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 456, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 456, scale);
                    return;
                }
                if (type == 321)
                {
                    Gore.NewGore(position, velocity, 457, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 458, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 458, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 459, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 459, scale);
                    return;
                }
                if (type == 223)
                {
                    Gore.NewGore(position, velocity, 309, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 310, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 310, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 311, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 311, scale);
                    return;
                }
                if (type == 132)
                {
                    Gore.NewGore(position, velocity, 154);
                }
                else if (type == 186 || type == 432)
                {
                    Gore.NewGore(position, velocity, 241);
                }
                else if (type == 189 || type == 435)
                {
                    Gore.NewGore(position, velocity, 246);
                }
                else if (type == 251)
                {
                    Gore.NewGore(position, velocity, 372);
                }
                else if (type != 187 && type != 433)
                {
                    Gore.NewGore(position, velocity, 3);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 4);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 4);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 5);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 5);
                if (type == 186 || type == 432)
                {
                    Gore.NewGore(position, velocity, 242);
                }
                if ((type == 186 || type == 432) && Main.rand.Next(2) == 0)
                {
                    Gore.NewGore(position, velocity, 242);
                }
            }
            else if (type == 83 || type == 84 || type == 179)
            {
                if (life > 0)
                {
                    for (int num541 = 0; (double)num541 < dmg / (double)lifeMax * 50.0; num541++)
                    {
                        int num542 = Dust.NewDust(position, width, height, 31, 0f, 0f, 0, default(Color), 1.5f);
                        Main.dust[num542].noGravity = true;
                    }
                    return;
                }
                for (int num543 = 0; num543 < 20; num543++)
                {
                    int num544 = Dust.NewDust(position, width, height, 31, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num544];
                    dust.velocity *= 2f;
                    Main.dust[num544].noGravity = true;
                }
                int num545 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(Main.rand.Next(-2, 3), Main.rand.Next(-2, 3)), 61, scale);
                Gore gore2 = Main.gore[num545];
                gore2.velocity *= 0.5f;
                num545 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(Main.rand.Next(-2, 3), Main.rand.Next(-2, 3)), 61, scale);
                gore2 = Main.gore[num545];
                gore2.velocity *= 0.5f;
                num545 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(Main.rand.Next(-2, 3), Main.rand.Next(-2, 3)), 61, scale);
                gore2 = Main.gore[num545];
                gore2.velocity *= 0.5f;
            }
            else if (type == 262 || type == 263 || type == 264)
            {
                if (life > 0)
                {
                    for (int num546 = 0; (double)num546 < dmg / (double)lifeMax * 100.0; num546++)
                    {
                        if (type == 262 && life > lifeMax / 2 && Main.rand.Next(3) != 0)
                        {
                            Dust.NewDust(position, width, height, 166, hitDirection, -1f);
                        }
                        else if (type == 265 && Main.rand.Next(3) != 0)
                        {
                            Dust.NewDust(position, width, height, 166, hitDirection, -1f);
                        }
                        else
                        {
                            Dust.NewDust(position, width, height, 167, hitDirection, -1f);
                        }
                    }
                    return;
                }
                for (int num547 = 0; num547 < 150; num547++)
                {
                    if (type == 265 && Main.rand.Next(3) != 0)
                    {
                        Dust.NewDust(position, width, height, 166, 2 * hitDirection, -2f);
                    }
                    else
                    {
                        Dust.NewDust(position, width, height, 167, 2 * hitDirection, -2f);
                    }
                }
                if (type == 262)
                {
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 381, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 382, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 383, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 384, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 385, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 386, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 386, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 387, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 387, scale);
                }
                if (type == 263)
                {
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 390, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 391, scale);
                }
                if (type == 264)
                {
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 388, scale);
                    Gore.NewGore(new Vector2(position.X + (float)Main.rand.Next(width), position.Y + (float)Main.rand.Next(height)), velocity, 389, scale);
                }
            }
            else if (type == 265)
            {
                if (life >= 0)
                {
                    return;
                }
                for (int num548 = 0; num548 < 15; num548++)
                {
                    if (Main.rand.Next(3) != 0)
                    {
                        Dust.NewDust(position, width, height, 166, hitDirection, -1f);
                    }
                    else
                    {
                        Dust.NewDust(position, width, height, 167, hitDirection, -1f);
                    }
                }
            }
            else if (type == 266)
            {
                if (life > 0)
                {
                    for (int num549 = 0; (double)num549 < dmg / (double)lifeMax * 100.0; num549++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num550 = 0; num550 < 150; num550++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 396);
                Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 397);
                Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 398);
                Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 399);
                Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 400);
                Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 401);
            }
            else if (type == 267)
            {
                if (life > 0)
                {
                    for (int num551 = 0; (double)num551 < dmg / (double)lifeMax * 50.0; num551++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num552 = 0; num552 < 20; num552++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 402);
            }
            else if (type == 4 || type == 126 || type == 125)
            {
                if (life > 0)
                {
                    for (int num553 = 0; (double)num553 < dmg / (double)lifeMax * 100.0; num553++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num554 = 0; num554 < 150; num554++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                for (int num555 = 0; num555 < 2; num555++)
                {
                    Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 2);
                    Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 7);
                    Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 9);
                    if (type == 4)
                    {
                        Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 10);
                        SoundEngine.PlaySound(15, (int)position.X, (int)position.Y, 0);
                    }
                    else if (type == 125)
                    {
                        Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 146);
                    }
                    else if (type == 126)
                    {
                        Gore.NewGore(position, new Vector2((float)Main.rand.Next(-30, 31) * 0.2f, (float)Main.rand.Next(-30, 31) * 0.2f), 145);
                    }
                }
                if (type == 125 || type == 126)
                {
                    for (int num556 = 0; num556 < 10; num556++)
                    {
                        int num557 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num557];
                        dust.velocity *= 1.4f;
                    }
                    for (int num558 = 0; num558 < 5; num558++)
                    {
                        int num559 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num559].noGravity = true;
                        Dust dust = Main.dust[num559];
                        dust.velocity *= 5f;
                        num559 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num559];
                        dust.velocity *= 3f;
                    }
                    int num560 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num560];
                    gore2.velocity *= 0.4f;
                    Main.gore[num560].velocity.X += 1f;
                    Main.gore[num560].velocity.Y += 1f;
                    num560 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num560];
                    gore2.velocity *= 0.4f;
                    Main.gore[num560].velocity.X -= 1f;
                    Main.gore[num560].velocity.Y += 1f;
                    num560 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num560];
                    gore2.velocity *= 0.4f;
                    Main.gore[num560].velocity.X += 1f;
                    Main.gore[num560].velocity.Y -= 1f;
                    num560 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num560];
                    gore2.velocity *= 0.4f;
                    Main.gore[num560].velocity.X -= 1f;
                    Main.gore[num560].velocity.Y -= 1f;
                }
            }
            else if (type == 5)
            {
                if (life > 0)
                {
                    for (int num561 = 0; (double)num561 < dmg / (double)lifeMax * 50.0; num561++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num562 = 0; num562 < 20; num562++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 6);
                Gore.NewGore(position, velocity, 7);
            }
            else if (type == 113 || type == 114)
            {
                if (life > 0)
                {
                    for (int num563 = 0; num563 < 20; num563++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num564 = 0; num564 < 50; num564++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -1f);
                }
                if (type == 114)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y), velocity, 137, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2)), velocity, 139, scale);
                    Gore.NewGore(new Vector2(position.X + (float)(width / 2), position.Y), velocity, 139, scale);
                    Gore.NewGore(new Vector2(position.X + (float)(width / 2), position.Y + (float)(height / 2)), velocity, 137, scale);
                    return;
                }
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, 137, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2)), velocity, 138, scale);
                Gore.NewGore(new Vector2(position.X + (float)(width / 2), position.Y), velocity, 138, scale);
                Gore.NewGore(new Vector2(position.X + (float)(width / 2), position.Y + (float)(height / 2)), velocity, 137, scale);
                if (!(Main.player[Main.myPlayer].position.Y / 16f > (float)(Main.maxTilesY - 250)))
                {
                    return;
                }
                int num565 = (int)Main.screenPosition.Y;
                int num566 = num565 + Main.screenWidth;
                int num567 = (int)position.X;
                if (direction > 0)
                {
                    num567 -= 80;
                }
                int num568 = num567 + 140;
                int num569 = num567;
                for (int num570 = num565; num570 < num566; num570 += 50)
                {
                    for (; num569 < num568; num569 += 46)
                    {
                        for (int num571 = 0; num571 < 5; num571++)
                        {
                            Dust.NewDust(new Vector2(num569, num570), 32, 32, 5, (float)Main.rand.Next(-60, 61) * 0.1f, (float)Main.rand.Next(-60, 61) * 0.1f);
                        }
                        Gore.NewGore(Velocity: new Vector2((float)Main.rand.Next(-80, 81) * 0.1f, (float)Main.rand.Next(-60, 21) * 0.1f), Position: new Vector2(num569, num570), Type: Main.rand.Next(140, 143));
                    }
                    num569 = num567;
                }
            }
            else if (type == 115 || type == 116)
            {
                if (life > 0)
                {
                    for (int num572 = 0; num572 < 5; num572++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                if (type == 115 && Main.netMode != 1)
                {
                    NewNPC(GetSpawnSource_NPCHurt(), (int)(position.X + (float)(width / 2)), (int)(position.Y + (float)height), 116);
                    for (int num573 = 0; num573 < 10; num573++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num574 = 0; num574 < 20; num574++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                Gore.NewGore(position, velocity, 132, scale);
                Gore.NewGore(position, velocity, 133, scale);
            }
            else if (type >= 117 && type <= 119)
            {
                if (life > 0)
                {
                    for (int num575 = 0; num575 < 5; num575++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num576 = 0; num576 < 10; num576++)
                {
                    Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                }
                Gore.NewGore(position, velocity, 134 + type - 117, scale);
            }
            else if (type == 217 || type == 218 || type == 219)
            {
                if (life > 0)
                {
                    for (int num577 = 0; (double)num577 < dmg / (double)lifeMax * 100.0; num577++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num578 = 0; num578 < 50; num578++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                if (type == 217)
                {
                    int num579 = Gore.NewGore(position, velocity, 292, scale);
                    num579 = Gore.NewGore(position, velocity, 293, scale);
                }
                if (type == 218)
                {
                    int num579 = Gore.NewGore(position, velocity, 295, scale);
                    num579 = Gore.NewGore(position, velocity, 296, scale);
                }
                if (type == 219)
                {
                    int num579 = Gore.NewGore(position, velocity, 294, scale);
                }
            }
            else if (type == 222)
            {
                if (life > 0)
                {
                    for (int num580 = 0; (double)num580 < dmg / (double)lifeMax * 100.0; num580++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num581 = 0; num581 < 50; num581++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                Gore.NewGore(new Vector2(position.X, position.Y - 35f), velocity, 303, scale);
                Gore.NewGore(new Vector2(position.X, position.Y - 45f), velocity, 304, scale);
                Gore.NewGore(new Vector2(position.X, position.Y), velocity, 305, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 306, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 10f), velocity, 307, scale);
                Gore.NewGore(new Vector2(position.X, position.Y - 10f), velocity, 308, scale);
            }
            else if (type == 6 || type == 94 || type == 166)
            {
                if (life > 0)
                {
                    for (int num582 = 0; (double)num582 < dmg / (double)lifeMax * 100.0; num582++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num583 = 0; num583 < 50; num583++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                if (type == 94)
                {
                    int num584 = Gore.NewGore(position, velocity, 108, scale);
                    num584 = Gore.NewGore(position, velocity, 108, scale);
                    num584 = Gore.NewGore(position, velocity, 109, scale);
                    num584 = Gore.NewGore(position, velocity, 110, scale);
                }
                else if (type == 166)
                {
                    int num584 = Gore.NewGore(position, velocity, 209, scale);
                    num584 = Gore.NewGore(position, velocity, 210, scale);
                    num584 = Gore.NewGore(position, velocity, 211, scale);
                }
                else
                {
                    int num584 = Gore.NewGore(position, velocity, 14, scale);
                    Main.gore[num584].alpha = alpha;
                    num584 = Gore.NewGore(position, velocity, 15, scale);
                    Main.gore[num584].alpha = alpha;
                }
            }
            else if (type == 101)
            {
                if (life > 0)
                {
                    for (int num585 = 0; (double)num585 < dmg / (double)lifeMax * 100.0; num585++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num586 = 0; num586 < 50; num586++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                int num587 = Gore.NewGore(position, velocity, 110, scale);
                num587 = Gore.NewGore(position, velocity, 114, scale);
                num587 = Gore.NewGore(position, velocity, 114, scale);
                num587 = Gore.NewGore(position, velocity, 115, scale);
            }
            else if (type == 7 || type == 8 || type == 9)
            {
                if (life > 0)
                {
                    for (int num588 = 0; (double)num588 < dmg / (double)lifeMax * 100.0; num588++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num589 = 0; num589 < 50; num589++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                int num590 = Gore.NewGore(position, velocity, type - 7 + 18);
                Main.gore[num590].alpha = alpha;
            }
            else if (type == 98 || type == 99 || type == 100)
            {
                if (life > 0)
                {
                    for (int num591 = 0; (double)num591 < dmg / (double)lifeMax * 100.0; num591++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num592 = 0; num592 < 50; num592++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                int num593 = Gore.NewGore(position, velocity, 110);
                Main.gore[num593].alpha = alpha;
            }
            else if (type == 10 || type == 11 || type == 12)
            {
                if (life > 0)
                {
                    for (int num594 = 0; (double)num594 < dmg / (double)lifeMax * 50.0; num594++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num595 = 0; num595 < 10; num595++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, type - 7 + 18);
            }
            else if (type == 95 || type == 96 || type == 97)
            {
                if (life > 0)
                {
                    for (int num596 = 0; (double)num596 < dmg / (double)lifeMax * 50.0; num596++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num597 = 0; num597 < 10; num597++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, type - 95 + 111);
            }
            else if (type == 13 || type == 14 || type == 15)
            {
                if (life > 0)
                {
                    for (int num598 = 0; (double)num598 < dmg / (double)lifeMax * 100.0; num598++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num599 = 0; num599 < 50; num599++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                if (type == 13)
                {
                    Gore.NewGore(position, velocity, 24);
                    Gore.NewGore(position, velocity, 25);
                }
                else if (type == 14)
                {
                    Gore.NewGore(position, velocity, 26);
                    Gore.NewGore(position, velocity, 27);
                }
                else
                {
                    Gore.NewGore(position, velocity, 28);
                    Gore.NewGore(position, velocity, 29);
                }
            }
            else if (type == 17)
            {
                if (life > 0)
                {
                    for (int num600 = 0; (double)num600 < dmg / (double)lifeMax * 100.0; num600++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num601 = 0; num601 < 50; num601++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1320 : 30);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1322 : 31);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1322 : 31);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1323 : 32);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1323 : 32);
            }
            else if (type == 441)
            {
                if (life > 0)
                {
                    for (int num602 = 0; (double)num602 < dmg / (double)lifeMax * 100.0; num602++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num603 = 0; num603 < 50; num603++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1358 : 768);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1359 : 769);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1361 : 770);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1360 : 771);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1360 : 771);
            }
            else if (type == 86)
            {
                if (life > 0)
                {
                    for (int num604 = 0; (double)num604 < dmg / (double)lifeMax * 100.0; num604++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num605 = 0; num605 < 50; num605++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 101);
                Gore.NewGore(position, velocity, 102);
                Gore.NewGore(position, velocity, 103);
                Gore.NewGore(position, velocity, 103);
                Gore.NewGore(position, velocity, 104);
                Gore.NewGore(position, velocity, 104);
                Gore.NewGore(position, velocity, 105);
            }
            else if (type == 155)
            {
                if (life > 0)
                {
                    for (int num606 = 0; (double)num606 < dmg / (double)lifeMax * 100.0; num606++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num607 = 0; num607 < 50; num607++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 181);
                Gore.NewGore(position, velocity, 182);
                Gore.NewGore(position, velocity, 183);
            }
            else if (type == 329)
            {
                if (life > 0)
                {
                    for (int num608 = 0; (double)num608 < dmg / (double)lifeMax * 100.0; num608++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num609 = 0; num609 < 50; num609++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 485);
                Gore.NewGore(position, velocity, 486);
                Gore.NewGore(position, velocity, 487);
            }
            else if (type == 163 || type == 238)
            {
                if (life > 0)
                {
                    for (int num610 = 0; (double)num610 < dmg / (double)lifeMax * 100.0; num610++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f);
                    }
                    return;
                }
                for (int num611 = 0; num611 < 50; num611++)
                {
                    Dust.NewDust(position, width, height, 18, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 205);
                Gore.NewGore(position, velocity, 206);
                Gore.NewGore(position, velocity, 206);
                Gore.NewGore(position, velocity, 206);
                Gore.NewGore(position, velocity, 206);
            }
            else if (type == 164 || type == 165)
            {
                if (life > 0)
                {
                    for (int num612 = 0; (double)num612 < dmg / (double)lifeMax * 100.0; num612++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f);
                    }
                    return;
                }
                for (int num613 = 0; num613 < 50; num613++)
                {
                    Dust.NewDust(position, width, height, 18, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 207);
                Gore.NewGore(position, velocity, 208);
                Gore.NewGore(position, velocity, 208);
                Gore.NewGore(position, velocity, 208);
                Gore.NewGore(position, velocity, 208);
            }
            else if (type == 239 || type == 240)
            {
                if (life > 0)
                {
                    for (int num614 = 0; (double)num614 < dmg / (double)lifeMax * 100.0; num614++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num615 = 0; num615 < 50; num615++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 351);
                Gore.NewGore(position, velocity, 352);
                Gore.NewGore(position, velocity, 352);
                Gore.NewGore(position, velocity, 353);
                Gore.NewGore(position, velocity, 353);
            }
            else if (type == 236 || type == 237)
            {
                if (life > 0)
                {
                    for (int num616 = 0; (double)num616 < dmg / (double)lifeMax * 100.0; num616++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f);
                    }
                    return;
                }
                for (int num617 = 0; num617 < 50; num617++)
                {
                    Dust.NewDust(position, width, height, 18, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 332);
                Gore.NewGore(position, velocity, 333);
                Gore.NewGore(position, velocity, 334);
                Gore.NewGore(position, velocity, 335);
                Gore.NewGore(position, velocity, 335);
            }
            else if (type == 241)
            {
                if (life > 0)
                {
                    for (int num618 = 0; (double)num618 < dmg / (double)lifeMax * 100.0; num618++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num619 = 0; num619 < 50; num619++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 354);
                Gore.NewGore(position, velocity, 355);
            }
            else if (type == 242)
            {
                if (life > 0)
                {
                    for (int num620 = 0; (double)num620 < dmg / (double)lifeMax * 100.0; num620++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num621 = 0; num621 < 50; num621++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 356);
                Gore.NewGore(position, velocity, 357);
                Gore.NewGore(position, velocity, 357);
                Gore.NewGore(position, velocity, 358);
                Gore.NewGore(position, velocity, 358);
            }
            else if (type >= 105 && type <= 108)
            {
                if (life > 0)
                {
                    for (int num622 = 0; (double)num622 < dmg / (double)lifeMax * 100.0; num622++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num623 = 0; num623 < 50; num623++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 105 || type == 107)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1308 : 124);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1309 : 125);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1309 : 125);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1310 : 126);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1310 : 126);
                    return;
                }
                if (altTexture == 0 || type == 106)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1373 : 127);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1374 : 128);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1375 : 128);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1376 : 129);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1376 : 129);
            }
            else if (type == 123 || type == 124)
            {
                if (life > 0)
                {
                    for (int num624 = 0; (double)num624 < dmg / (double)lifeMax * 100.0; num624++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num625 = 0; num625 < 50; num625++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1317 : 151);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1318 : 152);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1318 : 152);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1319 : 153);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1319 : 153);
            }
            else if (type == 22)
            {
                if (life > 0)
                {
                    for (int num626 = 0; (double)num626 < dmg / (double)lifeMax * 100.0; num626++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num627 = 0; num627 < 50; num627++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1314 : 73);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1315 : 74);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1315 : 74);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1316 : 75);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1316 : 75);
            }
            else if (type == 550)
            {
                if (life > 0)
                {
                    for (int num628 = 0; (double)num628 < dmg / (double)lifeMax * 100.0; num628++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num629 = 0; num629 < 50; num629++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 0f), velocity, IsShimmerVariant ? 1355 : 967);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1356 : 968);
                Gore.NewGore(new Vector2(position.X + 8f, position.Y + 20f), velocity, IsShimmerVariant ? 1356 : 968);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1357 : 969);
                Gore.NewGore(new Vector2(position.X + 8f, position.Y + 34f), velocity, IsShimmerVariant ? 1357 : 969);
            }
            else if (type == 588 || type == 589)
            {
                if (life > 0)
                {
                    for (int num630 = 0; (double)num630 < dmg / (double)lifeMax * 100.0; num630++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num631 = 0; num631 < 50; num631++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 0f), velocity, IsShimmerVariant ? 1311 : 1109);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1312 : 1110);
                Gore.NewGore(new Vector2(position.X + 8f, position.Y + 20f), velocity, IsShimmerVariant ? 1312 : 1110);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1313 : 1111);
                Gore.NewGore(new Vector2(position.X + 8f, position.Y + 34f), velocity, IsShimmerVariant ? 1313 : 1111);
            }
            else if (type == 633)
            {
                if (life > 0)
                {
                    for (int num632 = 0; (double)num632 < dmg / (double)lifeMax * 100.0; num632++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num633 = 0; num633 < 50; num633++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                int num634 = 1219;
                int num635 = 1220;
                if (altTexture == 2)
                {
                    num634 = 1223;
                    num635 = 1224;
                }
                if (IsShimmerVariant)
                {
                    num634 = 1377;
                    num635 = 1379;
                    if (altTexture == 2)
                    {
                        num634 = 1378;
                        num635 = 1380;
                    }
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 0f), velocity, num634);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num635);
                Gore.NewGore(new Vector2(position.X + 8f, position.Y + 20f), velocity, num635);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1382 : 1221);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1381 : 1222);
                Gore.NewGore(new Vector2(position.X + 8f, position.Y + 34f), velocity, IsShimmerVariant ? 1381 : 1222);
            }
            else if (type == 368)
            {
                if (life > 0)
                {
                    for (int num636 = 0; (double)num636 < dmg / (double)lifeMax * 100.0; num636++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num637 = 0; num637 < 50; num637++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1362 : 567);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1364 : 568);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1364 : 568);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1365 : 569);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1365 : 569);
            }
            else if (type == 369 || type == 376 || type == 663 || NPCID.Sets.IsTownPet[type])
            {
                if (life <= 0)
                {
                    for (int num638 = 0; num638 < 25; num638++)
                    {
                        int num639 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 2f);
                        Dust dust = Main.dust[num639];
                        dust.velocity *= 1.4f;
                        Main.dust[num639].noLight = true;
                        Main.dust[num639].noGravity = true;
                    }
                    int num640 = 0;
                    num640 = Gore.NewGore(new Vector2(position.X + (float)(width / 2) - 24f, position.Y + (float)(height / 2) - 24f), default(Vector2), Main.rand.Next(61, 64));
                    Main.gore[num640].scale = 1f;
                    Main.gore[num640].velocity.X += 1f;
                    Main.gore[num640].velocity.Y += 1f;
                    num640 = Gore.NewGore(new Vector2(position.X + (float)(width / 2) - 24f, position.Y + (float)(height / 2) - 24f), default(Vector2), Main.rand.Next(61, 64));
                    Main.gore[num640].scale = 1f;
                    Main.gore[num640].velocity.X -= 1f;
                    Main.gore[num640].velocity.Y += 1f;
                    num640 = Gore.NewGore(new Vector2(position.X + (float)(width / 2) - 24f, position.Y + (float)(height / 2) - 24f), default(Vector2), Main.rand.Next(61, 64));
                    Main.gore[num640].scale = 1f;
                    Main.gore[num640].velocity.X += 1f;
                    Main.gore[num640].velocity.Y -= 1f;
                    num640 = Gore.NewGore(new Vector2(position.X + (float)(width / 2) - 24f, position.Y + (float)(height / 2) - 24f), default(Vector2), Main.rand.Next(61, 64));
                    Main.gore[num640].scale = 1f;
                    Main.gore[num640].velocity.X -= 1f;
                    Main.gore[num640].velocity.Y -= 1f;
                }
            }
            else if (type == 227)
            {
                if (life > 0)
                {
                    for (int num641 = 0; (double)num641 < dmg / (double)lifeMax * 100.0; num641++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num642 = 0; num642 < 50; num642++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1331 : 320);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1334 : 321);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1333 : 322);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1332 : 323);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1332 : 323);
            }
            else if (type == 228)
            {
                if (life > 0)
                {
                    for (int num643 = 0; (double)num643 < dmg / (double)lifeMax * 100.0; num643++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num644 = 0; num644 < 50; num644++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1369 : 324);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1370 : 325);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1372 : 326);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1371 : 327);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1371 : 327);
            }
            else if (type == 229)
            {
                if (life > 0)
                {
                    for (int num645 = 0; (double)num645 < dmg / (double)lifeMax * 100.0; num645++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                if (IsShimmerVariant)
                {
                    for (int num646 = 0; num646 < 50; num646++)
                    {
                        int num647 = Dust.NewDust(position, width, height, 180, velocity.X, velocity.Y);
                        Dust dust = Main.dust[num647];
                        dust.velocity *= 2f;
                        Main.dust[num647].noGravity = true;
                        Main.dust[num647].scale = 1.4f;
                    }
                    return;
                }
                for (int num648 = 0; num648 < 50; num648++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, 328);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 329);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 329);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 330);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 330);
            }
            else if (type == 142)
            {
                if (life > 0)
                {
                    for (int num649 = 0; (double)num649 < dmg / (double)lifeMax * 100.0; num649++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num650 = 0; num650 < 50; num650++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1338 : 157);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1340 : 158);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1340 : 158);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1341 : 159);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1341 : 159);
            }
            else if (type == 178)
            {
                if (life > 0)
                {
                    for (int num651 = 0; (double)num651 < dmg / (double)lifeMax * 100.0; num651++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num652 = 0; num652 < 50; num652++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1348 : 231);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1349 : 232);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1349 : 232);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1350 : 233);
            }
            else if (type == 353 || type == 354)
            {
                if (life > 0)
                {
                    for (int num653 = 0; (double)num653 < dmg / (double)lifeMax * 100.0; num653++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num654 = 0; num654 < 50; num654++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1353 : 544);
                }
                if (!IsShimmerVariant)
                {
                    Gore.NewGore(position, velocity, 543);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1353 : 546);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1353 : 546);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1354 : 545);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1354 : 545);
            }
            else if (type == 37)
            {
                if (life > 0)
                {
                    for (int num655 = 0; (double)num655 < dmg / (double)lifeMax * 100.0; num655++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num656 = 0; num656 < 50; num656++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1328 : 58);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1329 : 59);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1329 : 59);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1330 : 60);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1330 : 60);
            }
            else if (type == 54)
            {
                if (life > 0)
                {
                    for (int num657 = 0; (double)num657 < dmg / (double)lifeMax * 100.0; num657++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num658 = 0; num658 < 50; num658++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1291 : 58);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1292 : 59);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1292 : 59);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1293 : 60);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1293 : 60);
            }
            else if (type == 160)
            {
                if (life > 0)
                {
                    for (int num659 = 0; (double)num659 < dmg / (double)lifeMax * 100.0; num659++)
                    {
                        Dust.NewDust(position, width, height, 26, hitDirection, -1f);
                    }
                    return;
                }
                for (int num660 = 0; num660 < 50; num660++)
                {
                    Dust.NewDust(position, width, height, 26, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1366 : 188);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1367 : 189);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1367 : 189);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1368 : 190);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1368 : 190);
            }
            else if (type == 18)
            {
                if (life > 0)
                {
                    for (int num661 = 0; (double)num661 < dmg / (double)lifeMax * 100.0; num661++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num662 = 0; num662 < 50; num662++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1324 : 33);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1326 : 34);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1326 : 34);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1327 : 35);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1327 : 35);
            }
            else if (type == 19)
            {
                if (life > 0)
                {
                    for (int num663 = 0; (double)num663 < dmg / (double)lifeMax * 100.0; num663++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num664 = 0; num664 < 50; num664++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1288 : 36);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1289 : 37);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1289 : 37);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1290 : 38);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1290 : 38);
            }
            else if (type == 38)
            {
                if (life > 0)
                {
                    for (int num665 = 0; (double)num665 < dmg / (double)lifeMax * 100.0; num665++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num666 = 0; num666 < 50; num666++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1297 : 64);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1299 : 65);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1299 : 65);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1300 : 66);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1300 : 66);
            }
            else if (type == 20)
            {
                if (life > 0)
                {
                    for (int num667 = 0; (double)num667 < dmg / (double)lifeMax * 100.0; num667++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num668 = 0; num668 < 50; num668++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1301 : 39);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1302 : 40);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1302 : 40);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1303 : 41);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1303 : 41);
            }
            else if (type == 207)
            {
                if (life > 0)
                {
                    for (int num669 = 0; (double)num669 < dmg / (double)lifeMax * 100.0; num669++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num670 = 0; num670 < 50; num670++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1304 : 283);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1306 : 284);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1306 : 284);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1307 : 285);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1307 : 285);
            }
            else if (type == 208)
            {
                if (life > 0)
                {
                    for (int num671 = 0; (double)num671 < dmg / (double)lifeMax * 100.0; num671++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num672 = 0; num672 < 50; num672++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1335 : 286);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1336 : 287);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1336 : 287);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1337 : 288);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1337 : 288);
            }
            else if (type == 663)
            {
                if (life > 0)
                {
                    for (int num673 = 0; (double)num673 < dmg / (double)lifeMax * 100.0; num673++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                }
                else
                {
                    for (int num674 = 0; num674 < 50; num674++)
                    {
                        Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                    }
                }
            }
            else if (type == 209)
            {
                if (life > 0)
                {
                    for (int num675 = 0; (double)num675 < dmg / (double)lifeMax * 100.0; num675++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num676 = 0; num676 < 50; num676++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, IsShimmerVariant ? 1294 : 289);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1295 : 290);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1295 : 290);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1296 : 291);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1296 : 291);
            }
            else if (type >= 212 && type <= 216)
            {
                if (life > 0)
                {
                    for (int num677 = 0; (double)num677 < dmg / (double)lifeMax * 100.0; num677++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num678 = 0; num678 < 50; num678++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 212)
                {
                    Gore.NewGore(position, velocity, 336);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 337);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 337);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 338);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 338);
                }
                else if (type == 213)
                {
                    Gore.NewGore(position, velocity, 339);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 340);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 340);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 341);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 341);
                }
                else if (type == 214)
                {
                    Gore.NewGore(position, velocity, 342);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 343);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 343);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 344);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 344);
                }
                else if (type == 215)
                {
                    Gore.NewGore(position, velocity, 345);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 346);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 346);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 347);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 347);
                }
                else if (type == 216)
                {
                    Gore.NewGore(position, velocity, 348);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 349);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 349);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 350);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 350);
                }
            }
            else if (type == 220 || type == 221)
            {
                if (life > 0)
                {
                    for (int num679 = 0; (double)num679 < dmg / (double)lifeMax * 50.0; num679++)
                    {
                        Dust.NewDust(position, width, height, 151, hitDirection, -1f, 0, default(Color), 0.7f);
                    }
                    return;
                }
                for (int num680 = 0; num680 < 20; num680++)
                {
                    Dust.NewDust(position, width, height, 151, 2.5f * (float)hitDirection, -2.5f, 0, default(Color), 0.7f);
                }
                if (type == 221)
                {
                    Gore.NewGore(position, velocity, 298, scale);
                    Gore.NewGore(position, velocity, 299, scale);
                }
                else
                {
                    Gore.NewGore(position, velocity, 297, scale);
                }
            }
            else if (type == 21 || type == 31 || type == 294 || type == 295 || type == 296 || type == 32 || type == 44 || type == 45 || type == 77 || type == 110 || type == 167 || type == 197 || type == 201 || type == 202 || type == 203 || type == 287 || type == 291 || type == 292 || type == 293 || (type >= 322 && type <= 324) || type == 481 || (type >= 449 && type <= 452))
            {
                if (life > 0)
                {
                    for (int num681 = 0; (double)num681 < dmg / (double)lifeMax * 50.0; num681++)
                    {
                        Dust.NewDust(position, width, height, 26, hitDirection, -1f);
                    }
                    return;
                }
                for (int num682 = 0; num682 < 20; num682++)
                {
                    Dust.NewDust(position, width, height, 26, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 167)
                {
                    Gore.NewGore(position, velocity, 213, scale);
                    Gore.NewGore(position, velocity, 214, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 212, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 212, scale);
                    return;
                }
                if (type == 197)
                {
                    Gore.NewGore(position, velocity, 257, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 212, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 212, scale);
                    return;
                }
                if (type == 481)
                {
                    Gore.NewGore(position, velocity, 695, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 696, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 696, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 697, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 697, scale);
                    return;
                }
                if (type == 201 || type == 450)
                {
                    Gore.NewGore(position, velocity, 265, scale);
                    Gore.NewGore(position, velocity, 267, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                    return;
                }
                if (type == 202 || type == 451)
                {
                    Gore.NewGore(position, velocity, 268, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                    return;
                }
                if (type == 203 || type == 452)
                {
                    Gore.NewGore(position, velocity, 269, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 266, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 266, scale);
                    return;
                }
                if (type == 322)
                {
                    Gore.NewGore(position, velocity, 460, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 461, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 462, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 461, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 462, scale);
                    return;
                }
                if (type == 323)
                {
                    Gore.NewGore(position, velocity, 463, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 465, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 464, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 464, scale);
                    return;
                }
                if (type == 324)
                {
                    Gore.NewGore(position, velocity, 466, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 467, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 467, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 468, scale);
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 468, scale);
                    return;
                }
                Gore.NewGore(position, velocity, 42, scale);
                if (type == 77)
                {
                    Gore.NewGore(position, velocity, 106, scale);
                }
                if (type == 110)
                {
                    Gore.NewGore(position, velocity, 130, scale);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                if (type == 110)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 131, scale);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
            }
            else if (type == 453)
            {
                if (life > 0)
                {
                    for (int num683 = 0; (double)num683 < dmg / (double)lifeMax * 50.0; num683++)
                    {
                        Dust.NewDust(position, width, height, 26, hitDirection, -1f);
                    }
                    return;
                }
                for (int num684 = 0; num684 < 20; num684++)
                {
                    Dust.NewDust(position, width, height, 26, 2.5f * (float)hitDirection, -2.5f);
                }
                if (altTexture == 0)
                {
                    Gore.NewGore(position, velocity, IsShimmerVariant ? 1342 : 638, scale);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1346 : 639, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, IsShimmerVariant ? 1345 : 640, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1344 : 641, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, IsShimmerVariant ? 1347 : 642, scale);
            }
            else if ((type >= 269 && type <= 276) || (type >= 281 && type <= 286))
            {
                if (life > 0)
                {
                    for (int num685 = 0; (double)num685 < dmg / (double)lifeMax * 50.0; num685++)
                    {
                        Dust.NewDust(position, width, height, 26, hitDirection, -1f);
                    }
                    return;
                }
                for (int num686 = 0; num686 < 20; num686++)
                {
                    Dust.NewDust(position, width, height, 26, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 42, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 43, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 44, scale);
                if (type == 269)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 406, scale);
                }
                if (type == 270)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 407, scale);
                }
                if (type == 271 || type == 272)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 408, scale);
                }
                if (type == 274)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 409, scale);
                }
                if (type == 276)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 410, scale);
                }
            }
            else if (type >= 277 && type <= 280)
            {
                if (life > 0)
                {
                    for (int num687 = 0; (double)num687 < dmg / (double)lifeMax * 100.0; num687++)
                    {
                        int num688 = Dust.NewDust(position, width, height, 174, hitDirection, -1f);
                        Main.dust[num688].scale = 1.1f;
                        Main.dust[num688].noGravity = true;
                    }
                    return;
                }
                for (int num689 = 0; num689 < 75; num689++)
                {
                    int num690 = Dust.NewDust(position, width, height, 174, 1.5f * (float)hitDirection, -0.5f);
                    Dust dust = Main.dust[num690];
                    dust.velocity *= 2f;
                    Main.dust[num690].scale = 1.4f;
                    Main.dust[num690].noGravity = true;
                }
            }
            else if (type == 341)
            {
                int num691 = 196;
                if (life > 0)
                {
                    for (int num692 = 0; (double)num692 < dmg / (double)lifeMax * 50.0; num692++)
                    {
                        Dust.NewDust(position, width, height, num691);
                    }
                    return;
                }
                for (int num693 = 0; num693 < 20; num693++)
                {
                    Dust.NewDust(position, width, height, num691);
                }
                int num694 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 61, scale);
                Gore gore2 = Main.gore[num694];
                gore2.velocity *= 0.3f;
                num694 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), 62, scale);
                gore2 = Main.gore[num694];
                gore2.velocity *= 0.3f;
                num694 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 10f), new Vector2(hitDirection, 0f), 63, scale);
                gore2 = Main.gore[num694];
                gore2.velocity *= 0.3f;
            }
            else if (type == 85 || type == 629)
            {
                int num695 = 7;
                if (ai[3] == 2f)
                {
                    num695 = 10;
                }
                if (ai[3] == 3f)
                {
                    num695 = 37;
                }
                if (life > 0)
                {
                    for (int num696 = 0; (double)num696 < dmg / (double)lifeMax * 50.0; num696++)
                    {
                        Dust.NewDust(position, width, height, num695);
                    }
                    return;
                }
                for (int num697 = 0; num697 < 20; num697++)
                {
                    Dust.NewDust(position, width, height, num695);
                }
                int num698 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 61, scale);
                Gore gore2 = Main.gore[num698];
                gore2.velocity *= 0.3f;
                num698 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), 62, scale);
                gore2 = Main.gore[num698];
                gore2.velocity *= 0.3f;
                num698 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 10f), new Vector2(hitDirection, 0f), 63, scale);
                gore2 = Main.gore[num698];
                gore2.velocity *= 0.3f;
            }
            else if (type == 473 || type == 474 || type == 475 || type == 476)
            {
                int num699 = 31;
                if (life > 0)
                {
                    for (int num700 = 0; (double)num700 < dmg / (double)lifeMax * 50.0; num700++)
                    {
                        Dust.NewDust(position, width, height, num699);
                    }
                    return;
                }
                for (int num701 = 0; num701 < 20; num701++)
                {
                    Dust.NewDust(position, width, height, num699);
                }
                int num702 = Gore.NewGore(base.Center, new Vector2(hitDirection, 0f), 61, scale);
                Gore gore2 = Main.gore[num702];
                gore2.velocity *= 0.3f;
                num702 = Gore.NewGore(base.Center, new Vector2(hitDirection, 0f), 62, scale);
                gore2 = Main.gore[num702];
                gore2.velocity *= 0.3f;
                num702 = Gore.NewGore(base.Center, new Vector2(hitDirection, 0f), 63, scale);
                gore2 = Main.gore[num702];
                gore2.velocity *= 0.3f;
            }
            else if (type == 169)
            {
                if (life > 0)
                {
                    for (int num703 = 0; (double)num703 < dmg / (double)lifeMax * 50.0; num703++)
                    {
                        int num704 = Dust.NewDust(position, width, height, 92, 0f, 0f, 0, default(Color), 1.5f);
                        Dust dust = Main.dust[num704];
                        dust.velocity *= 1.5f;
                        Main.dust[num704].noGravity = true;
                    }
                    return;
                }
                for (int num705 = 0; num705 < 100; num705++)
                {
                    int num706 = Dust.NewDust(position, width, height, 92, 0f, 0f, 0, default(Color), 1.5f);
                    Main.dust[num706].scale = 1.5f;
                    Dust dust = Main.dust[num706];
                    dust.velocity *= 2f;
                    Main.dust[num706].noGravity = true;
                }
            }
            else if (type == 170 || type == 180)
            {
                if (life > 0)
                {
                    for (int num707 = 0; (double)num707 < dmg / (double)lifeMax * 50.0; num707++)
                    {
                        int num708 = Dust.NewDust(position, width, height, 54, 0f, 0f, 0, default(Color), 1.5f);
                        Dust dust = Main.dust[num708];
                        dust.velocity *= 1.5f;
                        Main.dust[num708].noGravity = true;
                    }
                    return;
                }
                for (int num709 = 0; num709 < 10; num709++)
                {
                    int num710 = Dust.NewDust(position, width, height, 54, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num710];
                    dust.velocity *= 2f;
                    Main.dust[num710].noGravity = true;
                }
                for (int num711 = 0; num711 < 4; num711++)
                {
                    int num712 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), 99, scale);
                    Gore gore2 = Main.gore[num712];
                    gore2.velocity *= 0.3f;
                }
            }
            else if (type == 171)
            {
                if (life > 0)
                {
                    for (int num713 = 0; (double)num713 < dmg / (double)lifeMax * 50.0; num713++)
                    {
                        int num714 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                        Dust dust = Main.dust[num714];
                        dust.velocity *= 1.5f;
                        Main.dust[num714].noGravity = true;
                    }
                    return;
                }
                for (int num715 = 0; num715 < 10; num715++)
                {
                    int num716 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num716];
                    dust.velocity *= 2f;
                    Main.dust[num716].noGravity = true;
                }
                for (int num717 = 0; num717 < 4; num717++)
                {
                    int num718 = 11 + num717;
                    if (num718 > 13)
                    {
                        num718 = Main.rand.Next(11, 14);
                    }
                    int num719 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), num718, scale);
                    Gore gore2 = Main.gore[num719];
                    gore2.velocity *= 0.3f;
                }
            }
            else if (type == 290)
            {
                if (life <= 0)
                {
                    for (int num720 = 0; num720 < 10; num720++)
                    {
                        int num721 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                        Dust dust = Main.dust[num721];
                        dust.velocity *= 2f;
                        Main.dust[num721].noGravity = true;
                    }
                    int num722 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(11, 14), scale);
                    Gore gore2 = Main.gore[num722];
                    gore2.velocity *= 0.5f;
                    num722 = Gore.NewGore(new Vector2(position.X, position.Y + 20f), default(Vector2), Main.rand.Next(11, 14), scale);
                    gore2 = Main.gore[num722];
                    gore2.velocity *= 0.5f;
                    num722 = Gore.NewGore(new Vector2(position.X, position.Y + 40f), default(Vector2), Main.rand.Next(11, 14), scale);
                    gore2 = Main.gore[num722];
                    gore2.velocity *= 0.5f;
                }
            }
            else if (type >= 87 && type <= 92)
            {
                if (life > 0)
                {
                    for (int num723 = 0; (double)num723 < dmg / (double)lifeMax * 50.0; num723++)
                    {
                        int num724 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                        Dust dust = Main.dust[num724];
                        dust.velocity *= 1.5f;
                        Main.dust[num724].noGravity = true;
                    }
                    return;
                }
                for (int num725 = 0; num725 < 10; num725++)
                {
                    int num726 = Dust.NewDust(position, width, height, 16, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num726];
                    dust.velocity *= 2f;
                    Main.dust[num726].noGravity = true;
                }
                int num727 = Main.rand.Next(1, 4);
                for (int num728 = 0; num728 < num727; num728++)
                {
                    int num729 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), Main.rand.Next(11, 14), scale);
                    Gore gore2 = Main.gore[num729];
                    gore2.velocity *= 0.8f;
                }
            }
            else if (type == 78 || type == 79 || type == 80 || type == 630)
            {
                if (life > 0)
                {
                    for (int num730 = 0; (double)num730 < dmg / (double)lifeMax * 50.0; num730++)
                    {
                        int num731 = Dust.NewDust(position, width, height, 31, 0f, 0f, 0, default(Color), 1.5f);
                        Dust dust = Main.dust[num731];
                        dust.velocity *= 2f;
                        Main.dust[num731].noGravity = true;
                    }
                    return;
                }
                for (int num732 = 0; num732 < 20; num732++)
                {
                    int num733 = Dust.NewDust(position, width, height, 31, 0f, 0f, 0, default(Color), 1.5f);
                    Dust dust = Main.dust[num733];
                    dust.velocity *= 2f;
                    Main.dust[num733].noGravity = true;
                }
                int num734 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 61, scale);
                Gore gore2 = Main.gore[num734];
                gore2.velocity *= 0.3f;
                num734 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 10f), new Vector2(hitDirection, 0f), 62, scale);
                gore2 = Main.gore[num734];
                gore2.velocity *= 0.3f;
                num734 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 10f), new Vector2(hitDirection, 0f), 63, scale);
                gore2 = Main.gore[num734];
                gore2.velocity *= 0.3f;
            }
            else if (type == 82 || type == 158 || type == 159 || type == 250 || type == 253)
            {
                if (life > 0)
                {
                    for (int num735 = 0; (double)num735 < dmg / (double)lifeMax * 50.0; num735++)
                    {
                        int num736 = Dust.NewDust(position, width, height, 54, 0f, 0f, 50, default(Color), 1.5f);
                        Dust dust = Main.dust[num736];
                        dust.velocity *= 2f;
                        Main.dust[num736].noGravity = true;
                    }
                    return;
                }
                for (int num737 = 0; num737 < 20; num737++)
                {
                    int num738 = Dust.NewDust(position, width, height, 54, 0f, 0f, 50, default(Color), 1.5f);
                    Dust dust = Main.dust[num738];
                    dust.velocity *= 2f;
                    Main.dust[num738].noGravity = true;
                }
                int num739 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 99, scale);
                Gore gore2 = Main.gore[num739];
                gore2.velocity *= 0.3f;
                num739 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 15f), new Vector2(hitDirection, 0f), 99, scale);
                gore2 = Main.gore[num739];
                gore2.velocity *= 0.3f;
                num739 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 20f), new Vector2(hitDirection, 0f), 99, scale);
                gore2 = Main.gore[num739];
                gore2.velocity *= 0.3f;
            }
            else if (type == 316 || type == 330)
            {
                if (life > 0)
                {
                    for (int num740 = 0; (double)num740 < dmg / (double)lifeMax * 100.0; num740++)
                    {
                        int num741 = Dust.NewDust(position, width, height, 192, hitDirection, -1f, 100, new Color(100, 100, 100, 100));
                        Main.dust[num741].noGravity = true;
                    }
                }
                else
                {
                    for (int num742 = 0; num742 < 50; num742++)
                    {
                        int num743 = Dust.NewDust(position, width, height, 192, 2 * hitDirection, -2f, 100, new Color(100, 100, 100, 100));
                        Main.dust[num743].noGravity = true;
                    }
                }
            }
            else if (type == 662)
            {
                if (life > 0)
                {
                    for (int num744 = 0; (double)num744 < dmg / (double)lifeMax * 100.0; num744++)
                    {
                        int num745 = Dust.NewDust(position, width, height, 180, velocity.X, velocity.Y);
                        Dust dust = Main.dust[num745];
                        dust.velocity *= 2f;
                        Main.dust[num745].noGravity = true;
                        Main.dust[num745].scale = 1.4f;
                    }
                }
                else
                {
                    for (int num746 = 0; num746 < 50; num746++)
                    {
                        int num747 = Dust.NewDust(position, width, height, 180, velocity.X, velocity.Y);
                        Dust dust = Main.dust[num747];
                        dust.velocity *= 2f;
                        Main.dust[num747].noGravity = true;
                        Main.dust[num747].scale = 1.4f;
                    }
                }
            }
            else if (type == 315)
            {
                if (life > 0)
                {
                    for (int num748 = 0; (double)num748 < dmg / (double)lifeMax * 50.0; num748++)
                    {
                        int num749 = Dust.NewDust(position, width, height, 54, 0f, 0f, 50, default(Color), 1.5f);
                        Dust dust = Main.dust[num749];
                        dust.velocity *= 2f;
                        Main.dust[num749].noGravity = true;
                    }
                    return;
                }
                for (int num750 = 0; num750 < 20; num750++)
                {
                    int num751 = Dust.NewDust(position, width, height, 54, 0f, 0f, 50, default(Color), 1.5f);
                    Dust dust = Main.dust[num751];
                    dust.velocity *= 2f;
                    Main.dust[num751].noGravity = true;
                }
                int num752 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 99, scale);
                Gore gore2 = Main.gore[num752];
                gore2.velocity *= 0.3f;
                num752 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 15f), new Vector2(hitDirection, 0f), 99, scale);
                gore2 = Main.gore[num752];
                gore2.velocity *= 0.3f;
                num752 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 20f), new Vector2(hitDirection, 0f), 99, scale);
                gore2 = Main.gore[num752];
                gore2.velocity *= 0.3f;
                num752 = Gore.NewGore(new Vector2(position.X, position.Y), new Vector2(hitDirection, 0f), 446, scale);
                gore2 = Main.gore[num752];
                gore2.velocity *= 0.1f;
            }
            else if (type == 254 || type == 255 || type == 256 || type == 257 || type == 258 || type == 259 || type == 260 || type == 261 || type == 634 || type == 635)
            {
                if (life > 0)
                {
                    for (int num753 = 0; (double)num753 < dmg / (double)lifeMax * 50.0; num753++)
                    {
                        int num754 = Dust.NewDust(position, width, height, 165, 0f, 0f, 50, default(Color), 1.5f);
                        Dust dust = Main.dust[num754];
                        dust.velocity *= 2f;
                        Main.dust[num754].noGravity = true;
                    }
                    return;
                }
                for (int num755 = 0; num755 < 20; num755++)
                {
                    int num756 = Dust.NewDust(position, width, height, 165, 0f, 0f, 50, default(Color), 1.5f);
                    Dust dust = Main.dust[num756];
                    dust.velocity *= 2f;
                    Main.dust[num756].noGravity = true;
                }
                if (type != 261)
                {
                    int num757 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 375, scale);
                    Gore gore2 = Main.gore[num757];
                    gore2.velocity *= 0.3f;
                    num757 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 15f), new Vector2(hitDirection, 0f), 376, scale);
                    gore2 = Main.gore[num757];
                    gore2.velocity *= 0.3f;
                    num757 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 20f), new Vector2(hitDirection, 0f), 377, scale);
                    gore2 = Main.gore[num757];
                    gore2.velocity *= 0.3f;
                }
            }
            else if (type == 140)
            {
                if (life <= 0)
                {
                    for (int num758 = 0; num758 < 20; num758++)
                    {
                        int num759 = Dust.NewDust(position, width, height, 54, 0f, 0f, 50, default(Color), 1.5f);
                        Dust dust = Main.dust[num759];
                        dust.velocity *= 2f;
                        Main.dust[num759].noGravity = true;
                    }
                    int num760 = Gore.NewGore(new Vector2(position.X, position.Y - 10f), new Vector2(hitDirection, 0f), 99, scale);
                    Gore gore2 = Main.gore[num760];
                    gore2.velocity *= 0.3f;
                    num760 = Gore.NewGore(new Vector2(position.X, position.Y + (float)(height / 2) - 15f), new Vector2(hitDirection, 0f), 99, scale);
                    gore2 = Main.gore[num760];
                    gore2.velocity *= 0.3f;
                    num760 = Gore.NewGore(new Vector2(position.X, position.Y + (float)height - 20f), new Vector2(hitDirection, 0f), 99, scale);
                    gore2 = Main.gore[num760];
                    gore2.velocity *= 0.3f;
                }
            }
            else if (type == 39 || type == 40 || type == 41)
            {
                if (life > 0)
                {
                    for (int num761 = 0; (double)num761 < dmg / (double)lifeMax * 50.0; num761++)
                    {
                        Dust.NewDust(position, width, height, 26, hitDirection, -1f);
                    }
                    return;
                }
                for (int num762 = 0; num762 < 20; num762++)
                {
                    Dust.NewDust(position, width, height, 26, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, type - 39 + 67);
            }
            else if (type == 34)
            {
                if (life > 0)
                {
                    for (int num763 = 0; (double)num763 < dmg / (double)lifeMax * 30.0; num763++)
                    {
                        int num764 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 15, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 1.8f);
                        Main.dust[num764].noLight = true;
                        Main.dust[num764].noGravity = true;
                        Dust dust = Main.dust[num764];
                        dust.velocity *= 1.3f;
                        num764 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 26, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 0, default(Color), 0.9f);
                        Main.dust[num764].noLight = true;
                        dust = Main.dust[num764];
                        dust.velocity *= 1.3f;
                    }
                }
                else
                {
                    for (int num765 = 0; num765 < 15; num765++)
                    {
                        int num766 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 15, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 1.8f);
                        Main.dust[num766].noLight = true;
                        Main.dust[num766].noGravity = true;
                        Dust dust = Main.dust[num766];
                        dust.velocity *= 1.3f;
                        num766 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 26, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 0, default(Color), 0.9f);
                        Main.dust[num766].noLight = true;
                        dust = Main.dust[num766];
                        dust.velocity *= 1.3f;
                    }
                }
            }
            else if (type == 289)
            {
                if (life > 0)
                {
                    for (int num767 = 0; (double)num767 < dmg / (double)lifeMax * 30.0; num767++)
                    {
                        int num768 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 181, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 1.8f);
                        Main.dust[num768].noLight = true;
                        Main.dust[num768].noGravity = true;
                        Dust dust = Main.dust[num768];
                        dust.velocity *= 1.3f;
                    }
                }
                else
                {
                    for (int num769 = 0; num769 < 50; num769++)
                    {
                        int num770 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 181, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 1.8f);
                        Main.dust[num770].noLight = true;
                        Main.dust[num770].noGravity = true;
                        Dust dust = Main.dust[num770];
                        dust.velocity *= 1.3f;
                    }
                }
            }
            else if (type == 35 || type == 36)
            {
                if (life > 0)
                {
                    for (int num771 = 0; (double)num771 < dmg / (double)lifeMax * 100.0; num771++)
                    {
                        Dust.NewDust(position, width, height, 26, hitDirection, -1f);
                    }
                    return;
                }
                for (int num772 = 0; num772 < 150; num772++)
                {
                    Dust.NewDust(position, width, height, 26, 2.5f * (float)hitDirection, -2.5f);
                }
                if (type == 35)
                {
                    Gore.NewGore(position, velocity, 54);
                    Gore.NewGore(position, velocity, 55);
                    return;
                }
                Gore.NewGore(position, velocity, 56);
                Gore.NewGore(position, velocity, 57);
                Gore.NewGore(position, velocity, 57);
                Gore.NewGore(position, velocity, 57);
            }
            else if (type == 139)
            {
                if (life <= 0)
                {
                    for (int num773 = 0; num773 < 10; num773++)
                    {
                        int num774 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num774];
                        dust.velocity *= 1.4f;
                    }
                    for (int num775 = 0; num775 < 5; num775++)
                    {
                        int num776 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num776].noGravity = true;
                        Dust dust = Main.dust[num776];
                        dust.velocity *= 5f;
                        num776 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num776];
                        dust.velocity *= 3f;
                    }
                    int num777 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num777];
                    gore2.velocity *= 0.4f;
                    Main.gore[num777].velocity.X += 1f;
                    Main.gore[num777].velocity.Y += 1f;
                    num777 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num777];
                    gore2.velocity *= 0.4f;
                    Main.gore[num777].velocity.X -= 1f;
                    Main.gore[num777].velocity.Y += 1f;
                    num777 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num777];
                    gore2.velocity *= 0.4f;
                    Main.gore[num777].velocity.X += 1f;
                    Main.gore[num777].velocity.Y -= 1f;
                    num777 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num777];
                    gore2.velocity *= 0.4f;
                    Main.gore[num777].velocity.X -= 1f;
                    Main.gore[num777].velocity.Y -= 1f;
                }
            }
            else if (type == 467)
            {
                if (life <= 0)
                {
                    for (int num778 = 0; num778 < 7; num778++)
                    {
                        int num779 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num779];
                        dust.velocity *= 1.4f;
                    }
                    for (int num780 = 0; num780 < 3; num780++)
                    {
                        int num781 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num781].noGravity = true;
                        Dust dust = Main.dust[num781];
                        dust.velocity *= 5f;
                        num781 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num781];
                        dust.velocity *= 3f;
                    }
                    Gore.NewGore(position, velocity, 660);
                    Gore.NewGore(position, velocity, 660);
                }
            }
            else if (type >= 134 && type <= 136)
            {
                if (type == 135 && life > 0 && Main.netMode != 1)
                {
                    int maxValue = 25;
                    if (IsMechQueenUp)
                    {
                        maxValue = 50;
                    }
                    if (ai[2] == 0f && Main.rand.Next(maxValue) == 0)
                    {
                        ai[2] = 1f;
                        int num782 = NewNPC(GetSpawnSource_NPCHurt(), (int)(position.X + (float)(width / 2)), (int)(position.Y + (float)height), 139);
                        if (Main.netMode == 2 && num782 < 200)
                        {
                            NetMessage.SendData(23, -1, -1, null, num782);
                        }
                        netUpdate = true;
                    }
                }
                if (life > 0)
                {
                    return;
                }
                Gore.NewGore(position, velocity, 156);
                if (Main.rand.Next(2) == 0)
                {
                    for (int num783 = 0; num783 < 10; num783++)
                    {
                        int num784 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num784];
                        dust.velocity *= 1.4f;
                    }
                    for (int num785 = 0; num785 < 5; num785++)
                    {
                        int num786 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num786].noGravity = true;
                        Dust dust = Main.dust[num786];
                        dust.velocity *= 5f;
                        num786 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num786];
                        dust.velocity *= 3f;
                    }
                    int num787 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num787];
                    gore2.velocity *= 0.4f;
                    Main.gore[num787].velocity.X += 1f;
                    Main.gore[num787].velocity.Y += 1f;
                    num787 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num787];
                    gore2.velocity *= 0.4f;
                    Main.gore[num787].velocity.X -= 1f;
                    Main.gore[num787].velocity.Y += 1f;
                    num787 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num787];
                    gore2.velocity *= 0.4f;
                    Main.gore[num787].velocity.X += 1f;
                    Main.gore[num787].velocity.Y -= 1f;
                    num787 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num787];
                    gore2.velocity *= 0.4f;
                    Main.gore[num787].velocity.X -= 1f;
                    Main.gore[num787].velocity.Y -= 1f;
                }
            }
            else if (type == 347)
            {
                if (life <= 0)
                {
                    Gore.NewGore(position, velocity, 524);
                    Gore.NewGore(position, velocity, 525);
                    Gore.NewGore(position, velocity, 526);
                    Gore.NewGore(position, velocity, 527);
                    for (int num788 = 0; num788 < 7; num788++)
                    {
                        int num789 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num789];
                        dust.velocity *= 1.4f;
                    }
                    for (int num790 = 0; num790 < 4; num790++)
                    {
                        int num791 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num791].noGravity = true;
                        Dust dust = Main.dust[num791];
                        dust.velocity *= 5f;
                        num791 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num791];
                        dust.velocity *= 3f;
                    }
                    int num792 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num792];
                    gore2.velocity *= 0.4f;
                    Main.gore[num792].velocity.X += 1f;
                    Main.gore[num792].velocity.Y += 1f;
                    num792 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num792];
                    gore2.velocity *= 0.4f;
                    Main.gore[num792].velocity.X -= 1f;
                    Main.gore[num792].velocity.Y -= 1f;
                }
            }
            else if (type == 346)
            {
                if (life <= 0)
                {
                    Gore.NewGore(position, velocity, 518);
                    Gore.NewGore(position, velocity, 519);
                    Gore.NewGore(position, velocity, 520);
                    Gore.NewGore(position, velocity, 521);
                    Gore.NewGore(position, velocity, 522);
                    Gore.NewGore(position, velocity, 523);
                    for (int num793 = 0; num793 < 10; num793++)
                    {
                        int num794 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num794];
                        dust.velocity *= 1.4f;
                    }
                    for (int num795 = 0; num795 < 5; num795++)
                    {
                        int num796 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num796].noGravity = true;
                        Dust dust = Main.dust[num796];
                        dust.velocity *= 5f;
                        num796 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num796];
                        dust.velocity *= 3f;
                    }
                    int num797 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num797];
                    gore2.velocity *= 0.4f;
                    Main.gore[num797].velocity.X += 1f;
                    Main.gore[num797].velocity.Y += 1f;
                    num797 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num797];
                    gore2.velocity *= 0.4f;
                    Main.gore[num797].velocity.X -= 1f;
                    Main.gore[num797].velocity.Y += 1f;
                    num797 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num797];
                    gore2.velocity *= 0.4f;
                    Main.gore[num797].velocity.X += 1f;
                    Main.gore[num797].velocity.Y -= 1f;
                    num797 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num797];
                    gore2.velocity *= 0.4f;
                    Main.gore[num797].velocity.X -= 1f;
                    Main.gore[num797].velocity.Y -= 1f;
                }
            }
            else if (type == 127)
            {
                if (life <= 0)
                {
                    Gore.NewGore(position, velocity, 149);
                    Gore.NewGore(position, velocity, 150);
                    for (int num798 = 0; num798 < 10; num798++)
                    {
                        int num799 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num799];
                        dust.velocity *= 1.4f;
                    }
                    for (int num800 = 0; num800 < 5; num800++)
                    {
                        int num801 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num801].noGravity = true;
                        Dust dust = Main.dust[num801];
                        dust.velocity *= 5f;
                        num801 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num801];
                        dust.velocity *= 3f;
                    }
                    int num802 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num802];
                    gore2.velocity *= 0.4f;
                    Main.gore[num802].velocity.X += 1f;
                    Main.gore[num802].velocity.Y += 1f;
                    num802 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num802];
                    gore2.velocity *= 0.4f;
                    Main.gore[num802].velocity.X -= 1f;
                    Main.gore[num802].velocity.Y += 1f;
                    num802 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num802];
                    gore2.velocity *= 0.4f;
                    Main.gore[num802].velocity.X += 1f;
                    Main.gore[num802].velocity.Y -= 1f;
                    num802 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num802];
                    gore2.velocity *= 0.4f;
                    Main.gore[num802].velocity.X -= 1f;
                    Main.gore[num802].velocity.Y -= 1f;
                }
            }
            else if (type >= 128 && type <= 131)
            {
                if (life <= 0)
                {
                    Gore.NewGore(position, velocity, 147);
                    Gore.NewGore(position, velocity, 148);
                    for (int num803 = 0; num803 < 10; num803++)
                    {
                        int num804 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 31, 0f, 0f, 100, default(Color), 1.5f);
                        Dust dust = Main.dust[num804];
                        dust.velocity *= 1.4f;
                    }
                    for (int num805 = 0; num805 < 5; num805++)
                    {
                        int num806 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 2.5f);
                        Main.dust[num806].noGravity = true;
                        Dust dust = Main.dust[num806];
                        dust.velocity *= 5f;
                        num806 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, 0f, 0f, 100, default(Color), 1.5f);
                        dust = Main.dust[num806];
                        dust.velocity *= 3f;
                    }
                    int num807 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    Gore gore2 = Main.gore[num807];
                    gore2.velocity *= 0.4f;
                    Main.gore[num807].velocity.X += 1f;
                    Main.gore[num807].velocity.Y += 1f;
                    num807 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num807];
                    gore2.velocity *= 0.4f;
                    Main.gore[num807].velocity.X -= 1f;
                    Main.gore[num807].velocity.Y += 1f;
                    num807 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num807];
                    gore2.velocity *= 0.4f;
                    Main.gore[num807].velocity.X += 1f;
                    Main.gore[num807].velocity.Y -= 1f;
                    num807 = Gore.NewGore(new Vector2(position.X, position.Y), default(Vector2), Main.rand.Next(61, 64));
                    gore2 = Main.gore[num807];
                    gore2.velocity *= 0.4f;
                    Main.gore[num807].velocity.X -= 1f;
                    Main.gore[num807].velocity.Y -= 1f;
                }
            }
            else if (type == 23)
            {
                if (life > 0)
                {
                    for (int num808 = 0; (double)num808 < dmg / (double)lifeMax * 100.0; num808++)
                    {
                        int num809 = 25;
                        if (Main.rand.Next(2) == 0)
                        {
                            num809 = 6;
                        }
                        Dust.NewDust(position, width, height, num809, hitDirection, -1f);
                        int num810 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, velocity.X * 0.2f, velocity.Y * 0.2f, 100, default(Color), 2f);
                        Main.dust[num810].noGravity = true;
                    }
                    return;
                }
                for (int num811 = 0; num811 < 50; num811++)
                {
                    int num812 = 25;
                    if (Main.rand.Next(2) == 0)
                    {
                        num812 = 6;
                    }
                    Dust.NewDust(position, width, height, num812, 2 * hitDirection, -2f);
                }
                for (int num813 = 0; num813 < 50; num813++)
                {
                    int num814 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, velocity.X * 0.2f, velocity.Y * 0.2f, 100, default(Color), 2.5f);
                    Dust dust = Main.dust[num814];
                    dust.velocity *= 6f;
                    Main.dust[num814].noGravity = true;
                }
            }
            else if (type == 24)
            {
                if (life > 0)
                {
                    for (int num815 = 0; (double)num815 < dmg / (double)lifeMax * 100.0; num815++)
                    {
                        int num816 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, velocity.X, velocity.Y, 100, default(Color), 2.5f);
                        Main.dust[num816].noGravity = true;
                    }
                    return;
                }
                for (int num817 = 0; num817 < 50; num817++)
                {
                    int num818 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, velocity.X, velocity.Y, 100, default(Color), 2.5f);
                    Main.dust[num818].noGravity = true;
                    Dust dust = Main.dust[num818];
                    dust.velocity *= 2f;
                }
                Gore.NewGore(position, velocity, 45);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 46);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 46);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 47);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 47);
            }
            else if (type == 25)
            {
                SoundEngine.PlaySound(SoundID.Item10, position);
                for (int num819 = 0; num819 < 20; num819++)
                {
                    int num820 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 2f);
                    Main.dust[num820].noGravity = true;
                    Dust dust = Main.dust[num820];
                    dust.velocity *= 2f;
                    num820 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 6, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100);
                    dust = Main.dust[num820];
                    dust.velocity *= 2f;
                }
            }
            else if (type == 33)
            {
                SoundEngine.PlaySound(SoundID.Item10, position);
                for (int num821 = 0; num821 < 20; num821++)
                {
                    int num822 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 172, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 1.2f);
                    Main.dust[num822].noGravity = true;
                    Dust dust = Main.dust[num822];
                    dust.velocity *= 2f;
                    num822 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 172, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 0.6f);
                    dust = Main.dust[num822];
                    dust.velocity *= 2f;
                }
            }
            else if (type == 26 || type == 27 || type == 28 || type == 29 || type == 73 || type == 111)
            {
                if (life > 0)
                {
                    for (int num823 = 0; (double)num823 < dmg / (double)lifeMax * 100.0; num823++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num824 = 0; num824 < 50; num824++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                int num825 = 48;
                int num826 = 49;
                int num827 = 50;
                if (type == 111)
                {
                    num825 = 623;
                    num826 = 624;
                    num827 = 625;
                }
                else if (type == 26)
                {
                    num825 = 626;
                    num826 = 627;
                    num827 = 628;
                }
                else if (type == 73)
                {
                    num825 = 629;
                    num826 = 630;
                    num827 = 631;
                }
                else if (type == 27)
                {
                    num825 = 632;
                    num826 = 633;
                    num827 = 634;
                }
                else if (type == 28)
                {
                    num825 = 635;
                    num826 = 636;
                    num827 = 637;
                }
                Gore.NewGore(position, velocity, num825, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num826, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, num826, scale);
                if (type == 111)
                {
                    Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 131, scale);
                }
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num827, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, num827, scale);
            }
            else if (type == 471)
            {
                if (life > 0)
                {
                    for (int num828 = 0; (double)num828 < dmg / (double)lifeMax * 100.0; num828++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num829 = 0; num829 < 50; num829++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 675, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 676, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 677, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 678, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 678, scale);
            }
            else if (type == 472)
            {
                if (life > 0)
                {
                    for (int num830 = 0; (double)num830 < dmg / (double)lifeMax * 100.0; num830++)
                    {
                        int num831 = Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                        if (Main.rand.Next(3) != 0)
                        {
                            Main.dust[num831].noGravity = true;
                        }
                        Main.dust[num831].alpha = 100;
                    }
                    return;
                }
                for (int num832 = 0; num832 < 50; num832++)
                {
                    int num833 = Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                    if (Main.rand.Next(3) != 0)
                    {
                        Main.dust[num833].noGravity = true;
                    }
                    Main.dust[num833].alpha = 100;
                }
                Gore.NewGore(position, velocity, 679, scale);
                Gore.NewGore(position, velocity, 680, scale);
            }
            else if (type == 480)
            {
                if (life > 0)
                {
                    for (int num834 = 0; (double)num834 < dmg / (double)lifeMax * 100.0; num834++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num835 = 0; num835 < 50; num835++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 692, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 693, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 20f), velocity, 693, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 694, scale);
                Gore.NewGore(new Vector2(position.X, position.Y + 34f), velocity, 694, scale);
            }
            else if (type == 185)
            {
                if (life > 0)
                {
                    for (int num836 = 0; (double)num836 < dmg / (double)lifeMax * 100.0; num836++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num837 = 0; num837 < 50; num837++)
                {
                    Dust.NewDust(position, width, height, 5, 2.5f * (float)hitDirection, -2.5f);
                }
                Gore.NewGore(position, velocity, 240, scale);
            }
            else if (type == 30 || type == 665)
            {
                SoundEngine.PlaySound(SoundID.Item10, position);
                for (int num838 = 0; num838 < 20; num838++)
                {
                    int num839 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 27, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100, default(Color), 2f);
                    Main.dust[num839].noGravity = true;
                    Dust dust = Main.dust[num839];
                    dust.velocity *= 2f;
                    num839 = Dust.NewDust(new Vector2(position.X, position.Y), width, height, 27, (0f - velocity.X) * 0.2f, (0f - velocity.Y) * 0.2f, 100);
                    dust = Main.dust[num839];
                    dust.velocity *= 2f;
                }
            }
            else if (type == 42 || type == 176 || type == 205 || (type >= 231 && type <= 235))
            {
                if (life > 0)
                {
                    for (int num840 = 0; (double)num840 < dmg / (double)lifeMax * 100.0; num840++)
                    {
                        Dust.NewDust(position, width, height, 18, hitDirection, -1f, alpha, this.color, scale);
                    }
                    return;
                }
                for (int num841 = 0; num841 < 50; num841++)
                {
                    Dust.NewDust(position, width, height, 18, hitDirection, -2f, alpha, this.color, scale);
                }
                if (type == 205)
                {
                    Gore.NewGore(position, velocity, 270, scale);
                    Gore.NewGore(position, velocity, 271, scale);
                    Gore.NewGore(position, velocity, 271, scale);
                    Gore.NewGore(position, velocity, 272, scale);
                }
                else if (type == 176)
                {
                    Gore.NewGore(position, velocity, 229, scale);
                    Gore.NewGore(position, velocity, 230, scale);
                }
                else
                {
                    Gore.NewGore(position, velocity, 70, scale);
                    Gore.NewGore(position, velocity, 71, scale);
                }
            }
            else if (type == 43 || type == 56)
            {
                if (life > 0)
                {
                    for (int num842 = 0; (double)num842 < dmg / (double)lifeMax * 100.0; num842++)
                    {
                        Dust.NewDust(position, width, height, 40, hitDirection, -1f, alpha, this.color, 1.2f);
                    }
                    return;
                }
                for (int num843 = 0; num843 < 50; num843++)
                {
                    Dust.NewDust(position, width, height, 40, hitDirection, -2f, alpha, this.color, 1.2f);
                }
                Gore.NewGore(position, velocity, 72);
                Gore.NewGore(position, velocity, 72);
            }
            else if (type == 175)
            {
                if (life > 0)
                {
                    for (int num844 = 0; (double)num844 < dmg / (double)lifeMax * 100.0; num844++)
                    {
                        Dust.NewDust(position, width, height, 40, hitDirection, -1f, alpha, this.color, 1.2f);
                    }
                    return;
                }
                for (int num845 = 0; num845 < 50; num845++)
                {
                    Dust.NewDust(position, width, height, 40, hitDirection, -2f, alpha, this.color, 1.2f);
                }
                Gore.NewGore(position, velocity, 227);
                Gore.NewGore(position, velocity, 228);
            }
            else if (type == 48)
            {
                if (life > 0)
                {
                    for (int num846 = 0; (double)num846 < dmg / (double)lifeMax * 100.0; num846++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num847 = 0; num847 < 50; num847++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 80);
                Gore.NewGore(position, velocity, 81);
            }
            else if (type == 62 || type == 66)
            {
                if (life > 0)
                {
                    for (int num848 = 0; (double)num848 < dmg / (double)lifeMax * 100.0; num848++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num849 = 0; num849 < 50; num849++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 93);
                Gore.NewGore(position, velocity, 94);
                Gore.NewGore(position, velocity, 94);
            }
            else
            {
                if (type != 156)
                {
                    return;
                }
                if (life > 0)
                {
                    for (int num850 = 0; (double)num850 < dmg / (double)lifeMax * 100.0; num850++)
                    {
                        Dust.NewDust(position, width, height, 5, hitDirection, -1f);
                    }
                    return;
                }
                for (int num851 = 0; num851 < 50; num851++)
                {
                    Dust.NewDust(position, width, height, 5, 2 * hitDirection, -2f);
                }
                Gore.NewGore(position, velocity, 184);
                Gore.NewGore(position, velocity, 185);
                Gore.NewGore(position, velocity, 185);
            }
        }
    }

References System.Math.Abs(), Terraria.Collision.CanHitLine(), Terraria.GameContent.Events.DD2Event.CheckProgress(), Terraria.Dust.CloneDust(), Microsoft.Xna.Framework.Graphics.Color, Microsoft.Xna.Framework.Matrix.CreateRotationZ(), Terraria.Main.dust, Terraria.Main.expertMode, ReLogic.Utilities.SlotId.FromFloat(), Terraria.Audio.SoundEngine.GetActiveSound(), Terraria.Main.getGoodWorld, Terraria.Main.gore, Microsoft.Xna.Framework.Color.HotPink, Terraria.Main.hslToRgb(), Terraria.ID.NPCID.Sets.IsTownPet, Terraria.ID.SoundID.Item10, Microsoft.Xna.Framework.Vector2.Length(), Microsoft.Xna.Framework.Color.Lerp(), Microsoft.Xna.Framework.Vector2.Lerp(), Microsoft.Xna.Framework.Color.LightBlue, Microsoft.Xna.Framework.Color.LightPink, Microsoft.Xna.Framework.Color.LightSeaGreen, Microsoft.Xna.Framework.Color.LimeGreen, Terraria.Main.maxTilesY, Terraria.Main.myPlayer, Terraria.Main.netMode, Terraria.Dust.NewDust(), Terraria.Dust.NewDustDirect(), Terraria.Gore.NewGore(), Terraria.Gore.NewGorePerfect(), Terraria.Projectile.NewProjectile(), Microsoft.Xna.Framework.Vector2.Normalize(), Terraria.Main.npc, Microsoft.Xna.Framework.Vector2.One, System.Math.PI, Terraria.Main.player, Terraria.Audio.SoundEngine.PlaySound(), Terraria.Utils.PoofOfSmoke(), Terraria.Main.rand, Terraria.Utils.RandomVector2(), Terraria.Main.remixWorld, Terraria.GameContent.Drawing.ParticleOrchestrator.RequestParticleSpawn(), Microsoft.Xna.Framework.Color.RoyalBlue, Terraria.Main.screenPosition, Terraria.Main.screenWidth, Terraria.NetMessage.SendData(), Microsoft.Xna.Framework.Color.SkyBlue, Terraria.WorldGen.SolidTile(), Terraria.Collision.SolidTiles(), Terraria.WorldGen.SquareTileFrame(), Terraria.GameContent.Events.MoonlordDeathDrama.ThrowPieces(), Terraria.Main.tile, Microsoft.Xna.Framework.Vector2.Transform(), Microsoft.Xna.Framework.Color.Transparent, System.type, Microsoft.Xna.Framework.Vector2.UnitX, Microsoft.Xna.Framework.Vector2.UnitY, System.value, Microsoft.Xna.Framework.Graphics.Vector2, Microsoft.Xna.Framework.Color.White, System.X, System.Y, and Microsoft.Xna.Framework.Vector2.Zero.

Referenced by Terraria.NPC.AI(), Terraria.NPC.AI_006_Worms(), Terraria.NPC.AI_007_TownEntities(), Terraria.NPC.AI_026_Unicorns(), Terraria.NPC.AI_037_Destroyer(), Terraria.NPC.AI_084_LunaticCultist(), Terraria.NPC.AI_107_ImprovedWalkers(), Terraria.NPC.AI_108_DivingFlyer(), Terraria.NPC.AI_113_WindyBalloon(), Terraria.NPC.AI_123_Deerclops(), and Terraria.NPC.AI_125_ClumsySlimeBalloon().