25236    {
25238        {
25239            int num = n.frame.Y / 
n.frame.Height;
 
25241            if (num >= 
array.Length)
 
25242            {
25243                num = 0;
25244            }
25247            switch (
n.GetPartyHatColor())
 
25248            {
25251                break;
25254                break;
25257                break;
25260                break;
25261            }
25263            rectangle.Width -= 2;
25264            rectangle.Height -= 2;
25267            int num5 = 
n.spriteDirection;
 
25269            {
25271            }
25273            {
25275                switch (num)
25276                {
25277                case 19:
25278                case 22:
25279                case 23:
25280                case 24:
25281                case 25:
25282                case 26:
25283                case 27:
25285                    break;
25286                case 11:
25287                case 12:
25288                case 13:
25289                case 14:
25290                case 15:
25292                    break;
25293                }
25294            }
25296            {
25298            }
25300            {
25302                switch (num)
25303                {
25304                case 1:
25305                case 2:
25306                case 3:
25308                    break;
25309                case 18:
25310                case 19:
25311                case 20:
25312                case 21:
25313                case 22:
25314                case 23:
25315                case 24:
25316                case 25:
25318                    break;
25319                case 8:
25321                    break;
25322                }
25323            }
25325            {
25328                {
25329                default:
25331                    break;
25332                case 670:
25334                    break;
25335                case 681:
25337                    break;
25338                case 682:
25341                    break;
25342                case 683:
25345                    break;
25346                case 684:
25348                    break;
25349                case 679:
25350                    break;
25351                }
25352            }
25353            if (
n.IsShimmerVariant)
 
25354            {
25356                {
25357                case 38:
25360                    break;
25361                case 178:
25362                case 228:
25365                    break;
25366                case 107:
25369                    break;
25370                case 54:
25372                    break;
25373                case 160:
25375                    break;
25376                case 108:
25377                case 124:
25378                case 208:
25379                case 209:
25380                case 227:
25382                    break;
25383                }
25384            }
25387            vector.Y += 
array[num];
 
25392            {
25395                {
25397                }
25399                {
25401                }
25403                {
25405                }
25407                {
25409                }
25410                if (
n.type == 108 || 
n.type == 178)
 
25411                {
25413                }
25415                {
25417                }
25419                {
25421                }
25422            }
25424            if (
n.type == 229 && 
n.ai[0] == 12f)
 
25425            {
25426                vector.X -= 
num5 * 4;
 
25427            }
25428            if (
n.type == 550 && 
n.ai[0] == 5f)
 
25429            {
25430                vector.X += 
num5 * 7;
 
25431            }
25435            {
25436            case 550:
25438                break;
25439            case 588:
25441                break;
25442            case 227:
25444                break;
25445            case 228:
25447                break;
25448            case 17:
25449            case 18:
25450            case 19:
25451            case 20:
25452            case 22:
25453            case 124:
25454            case 229:
25455            case 353:
25456            case 633:
25457            case 637:
25458            case 638:
25459            case 656:
25460            case 670:
25461            case 678:
25462            case 679:
25463            case 680:
25464            case 681:
25465            case 682:
25466            case 683:
25467            case 684:
25469                break;
25470            case 37:
25471            case 38:
25472            case 54:
25473            case 107:
25474            case 108:
25475            case 160:
25476            case 207:
25477            case 209:
25479                break;
25480            case 178:
25481            case 208:
25482            case 369:
25484                break;
25485            }
25487            vector.X += 4 * 
num5;
 
25490            {
25492            }
25494            if (
n.shimmerTransparency > 0f)
 
25495            {
25496                num8 *= 1f - 
n.shimmerTransparency;
 
25497            }
25499        }
25501        {
25503        }
25505        {
25506            if (
n.type == 228 || 
n.type == 229 || 
n.type == 209)
 
25507            {
25508                return;
25509            }
25510            float num9 = 
n.ai[2];
 
25512            if (
n.spriteDirection == 1)
 
25513            {
25514                vector2.X *= -1f;
25515            }
25517            if (
n.type == 22 && 
n.ai[2] > -0.1f)
 
25518            {
25519                vector3.Y += 4f;
25520            }
25521            if (
n.type == 368 && 
hardMode && 
n.ai[2] > -0.1f)
 
25522            {
25523                vector3.Y += 4f;
25524            }
25525            if (
n.type == 368 && !
hardMode && 
n.ai[2] < -0.1f)
 
25526            {
25527                vector3.Y -= 8f;
25528            }
25529            float rotation = 
num9 * ((float)
Math.
PI / 2f) * (float)
n.spriteDirection;
 
25534            {
25537                {
25538                    vector3.X -= 10 * 
n.direction;
 
25539                    vector3.Y += 4f;
25540                }
25541            }
25542            else if (
n.type == 22)
 
25543            {
25546            }
25547            else if (
n.type == 178)
 
25548            {
25550            }
25551            else if (
n.type == 227)
 
25552            {
25556            }
25557            else if (
n.type == 368)
 
25558            {
25561                {
25563                }
25564                else
25565                {
25566                    if (
n.ai[2] < -0.1f)
 
25567                    {
25569                    }
25571                }
25572            }
25577            if (
n.spriteDirection == -1)
 
25578            {
25580            }
25583            {
25585                if (
n.IsShimmerVariant)
 
25586                {
25588                }
25591            }
25593            {
25595                if (
n.IsShimmerVariant)
 
25596                {
25598                }
25601            }
25602        }
25604        {
25610        }
25612        {
25618            {
25622                {
25623                    return;
25624                }
25626                {
25627                    zero.Y = 12f;
25628                }
25629            }
25630            else if (
n.type == 353)
 
25631            {
25635                {
25636                    return;
25637                }
25639                {
25640                    zero.Y = 12f;
25641                }
25642            }
25643            else if (
n.type == 441)
 
25644            {
25649                {
25650                    return;
25651                }
25653                {
25654                    zero.Y = 12f;
25655                }
25656            }
25662        }
25663        if (
n.type == 550 && 
n.ai[0] == 18f)
 
25664        {
25666            {
25667                return;
25668            }
25672            float num17 = 0.15f;
 
25675            int num18 = (int)
n.ai[2];
 
25677            {
25679                bool flag = player.HeldItem.type == 353 && player.direction == 
Math.
Sign(
n.Center.X - 
player.Center.X);
 
25681                float num20 = 
n.localAI[3];
 
25682                if (
num19 < 46f && flag)
 
25683                {
25685                    if (
n.localAI[3] != 
num20)
 
25686                    {
25689                        for (
int i = 0; 
i < 30; 
i++)
 
25690                        {
25691                            Dust 
obj = Dust.NewDustDirect(
vector7 - 
vector8 / 2f, (
int)
vector8.X, (
int)
vector8.Y, 4, 0f, 0f, 50, 
new Microsoft.
Xna.
Framework.
Color(245, 200, 30, 155), 0.7f);
 
25692                            obj.noGravity = true;
25693                            obj.velocity *= 1f;
25694                            Dust.NewDustDirect(
vector7 - 
vector8 / 2f, (
int)
vector8.X, (
int)
vector8.Y, 4, 0f, 0f, 50, 
new Microsoft.
Xna.
Framework.
Color(245, 200, 30, 155), 0.6f).velocity *= 2f;
 
25695                        }
25696                    }
25697                }
25698                else if (
n.localAI[3] == 1f)
 
25699                {
25701                }
25702            }
25707        }
25709        {
25710            return;
25711        }
25712        int num21 = (int)
n.ai[2];
 
25714        {
25715            return;
25716        }
25719        num22 = (((int)
n.frameCounter < 6) ? 1 : 2);
 
25721        {
25723        }
25725        {
25726            return;
25727        }
25730        {
25732        }
25734        {
25736        }
25738        {
25739            vector10.X *= -1f;
25740        }
25742        {
25743            vector10.X *= 0.5f;
25744            vector10.Y += 4f;
25745        }
25747        {
25748            vector10.Y += 8f;
25749        }
25751        {
25753            {
25755            }
25756            vector10.Y += 6f;
25757        }
25763    }
static int Sign(decimal value)
 
static Asset< Texture2D >[] Npc
 
static Asset< Texture2D >[] Item
 
static Asset< Texture2D >[] Extra
 
static readonly short Count
 
static int[][] TownNPCsFramingGroups
 
static bool[] IsTownSlime
 
static int[] NPCFramingGroup
 
static Vector2[] OffsetsNPCOffhand
 
static int[] npcFrameCount
 
static SpriteBatch spriteBatch
 
static Vector2 screenPosition
 
static Vector2 DrawPlayerItemPos(float gravdir, int itemtype)
 
static void GetItemDrawFrame(int item, out Texture2D itemTexture, out Microsoft.Xna.Framework.Rectangle itemFrame)