Main.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Microsoft.Win32;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Newtonsoft.Json.Linq;
using ReLogic.Content;
using ReLogic.Content.Sources;
using ReLogic.Graphics;
using ReLogic.Localization.IME;
using ReLogic.OS;
using ReLogic.Peripherals.RGB;
using ReLogic.Utilities;
using Terraria.Achievements;
using Terraria.Audio;
using Terraria.Chat;
using Terraria.Cinematics;
using Terraria.DataStructures;
using Terraria.Enums;
using Terraria.GameContent;
using Terraria.GameContent.Achievements;
using Terraria.GameContent.Ambience;
using Terraria.GameContent.Animations;
using Terraria.GameContent.Bestiary;
using Terraria.GameContent.Creative;
using Terraria.GameContent.Drawing;
using Terraria.GameContent.Events;
using Terraria.GameContent.Golf;
using Terraria.GameContent.ItemDropRules;
using Terraria.GameContent.Liquid;
using Terraria.GameContent.NetModules;
using Terraria.GameContent.Skies;
using Terraria.GameContent.UI;
using Terraria.GameContent.UI.BigProgressBar;
using Terraria.GameContent.UI.Chat;
using Terraria.GameContent.UI.Minimap;
using Terraria.GameContent.UI.ResourceSets;
using Terraria.GameContent.UI.States;
using Terraria.GameInput;
using Terraria.Graphics;
using Terraria.Graphics.CameraModifiers;
using Terraria.Graphics.Capture;
using Terraria.Graphics.Effects;
using Terraria.Graphics.Light;
using Terraria.Graphics.Renderers;
using Terraria.Graphics.Shaders;
using Terraria.ID;
using Terraria.Initializers;
using Terraria.IO;
using Terraria.Localization;
using Terraria.Map;
using Terraria.Net;
using Terraria.ObjectData;
using Terraria.Social;
using Terraria.UI;
using Terraria.UI.Chat;
using Terraria.UI.Gamepad;
using Terraria.Utilities;
using Terraria.WorldBuilding;
 
namespace Terraria;
 
public class Main : Game
{
    public delegate void OnPlayerSelected(PlayerFileData player);
 
    public static class CurrentFrameFlags
    {
        public static class Hacks
        {
            public static Matrix CurrentBackgroundMatrixForCreditsRoll;
        }
 
        public static int ActivePlayersCount;
 
        public static int SleepingPlayersCount;
 
        public static bool AnyActiveBossNPC;
 
        public static bool HadAnActiveInteractibleProjectile;
    }
 
    public enum WorldPreparationState
    {
        AwaitingData,
        ProcessingData,
        Ready
    }
 
    internal static class NativeMethods
    {
        public const uint ES_CONTINUOUS = 2147483648u;
 
        public const uint ES_SYSTEM_REQUIRED = 1u;
 
        [DllImport("kernel32.dll")]
        public static extern uint SetThreadExecutionState(uint esFlags);
    }
 
    private struct MouseTextCache
    {
        public bool noOverride;
 
        public bool isValid;
 
        public string cursorText;
 
        public int rare;
 
        public byte diff;
 
        public int X;
 
        public int Y;
 
        public int hackedScreenWidth;
 
        public int hackedScreenHeight;
 
        public string buffTooltip;
    }
 
    protected class TextDisplayCache
    {
        private string _originalText;
 
        private int _lastScreenWidth;
 
        private int _lastScreenHeight;
 
        private InputMode _lastInputMode;
 
        public string[] TextLines { get; private set; }
 
        public int AmountOfLines { get; private set; }
 
        public void PrepareCache(string text)
        {
            if (false | (screenWidth != _lastScreenWidth) | (screenHeight != _lastScreenHeight) | (_originalText != text) | (PlayerInput.CurrentInputMode != _lastInputMode))
            {
                _lastScreenWidth = screenWidth;
                _lastScreenHeight = screenHeight;
                _originalText = text;
                _lastInputMode = PlayerInput.CurrentInputMode;
                text = Lang.SupportGlyphs(text);
                TextLines = Utils.WordwrapString(text, FontAssets.MouseText.Value, 460, 10, out var lineAmount);
                AmountOfLines = lineAmount;
            }
        }
    }
 
    public struct SceneArea
    {
        public Vector2 SceneLocalScreenPositionOffset;
 
        public float totalWidth;
 
        public float totalHeight;
 
        public int bgTopY;
    }
 
    public struct InfoToSetBackColor
    {
        public bool isInGameMenuOrIsServer;
 
        public float CorruptionBiomeInfluence;
 
        public float CrimsonBiomeInfluence;
 
        public float JungleBiomeInfluence;
 
        public float MushroomBiomeInfluence;
 
        public float GraveyardInfluence;
 
        public bool BloodMoonActive;
 
        public bool LanternNightActive;
    }
 
    private const string versionStringBecauseTheyreTheSame = "v1.4.4.9";
 
    public const int curRelease = 279;
 
    public const string assemblyVersionNumber = "1.4.4.9";
 
    public const string copyrightText = "Copyright © 2022 Re-Logic";
 
    public const ulong WorldGeneratorVersion = 1198295875585uL;
 
    public static int mapDelay = 2;
 
    public static IAssetRepository Assets;
 
    public static AssetSourceController AssetSourceController;
 
    private volatile bool _musicLoaded;
 
    private volatile bool _artLoaded;
 
    private volatile bool _begunMainAsyncLoad;
 
    public static int CurrentDrawnEntityShader;
 
    public static Entity CurrentDrawnEntity;
 
    private static bool GameAskedToQuit = false;
 
    public static float ForcedMinimumZoom = 1f;
 
    public static SpriteViewMatrix GameViewMatrix;
 
    public static SpriteViewMatrix BackgroundViewMatrix;
 
    private static Matrix _currentWantedZoomMatrix;
 
    private static Matrix _uiScaleMatrix;
 
    private static float _uiScaleWanted = 1f;
 
    private static float _uiScaleUsed = 1f;
 
    public static float GameZoomTarget = 1f;
 
    public static bool LightingEveryFrame = true;
 
    public static bool SettingsUnlock_WorldEvil;
 
    public static bool SettingsEnabled_MinersWobble = true;
 
    public static bool SettingsEnabled_AutoReuseAllItems = false;
 
    public static bool SettingBlockGamepadsEntirely;
 
    public static bool SettingDontScaleMainMenuUp;
 
    public static bool SettingsEnabled_OpaqueBoxBehindTooltips = true;
 
    public static bool SettingMusicReplayDelayEnabled = false;
 
    public static bool HidePassword;
 
    public static bool ReversedUpDownArmorSetBonuses;
 
    public static Microsoft.Xna.Framework.Color MouseBorderColor = new Microsoft.Xna.Framework.Color(64, 64, 64, 64);
 
    public static bool MouseShowBuildingGrid;
 
    public static bool AllowUnfocusedInputOnGamepad;
 
    public static bool InvisibleCursorForGamepad = true;
 
    public static bool GamepadDisableCursorItemIconInner = true;
 
    public static bool GamepadDisableInstructionsDisplay;
 
    public static bool CrouchingEnabled = false;
 
    private static GameNotificationType _flashNotificationType = GameNotificationType.All;
 
    public static float MouseBuildingGridAlpha;
 
    public static bool CaptureModeDisabled = false;
 
    public bool unityMouseOver;
 
    public static Main instance;
 
    public static ChromaEngine Chroma;
 
    public static ChromaHotkeyPainter ChromaPainter;
 
    public static Camera Camera = new Camera();
 
    public static IPlayerRenderer PlayerRenderer = new LegacyPlayerRenderer();
 
    public static IPlayerRenderer PotionOfReturnRenderer = new ReturnGatePlayerRenderer();
 
    public static MapHeadRenderer MapPlayerRenderer = new MapHeadRenderer();
 
    public static NPCHeadRenderer TownNPCHeadRenderer = null;
 
    public static NPCHeadRenderer BossNPCHeadRenderer = null;
 
    public static List<TitleLinkButton> TitleLinks = new List<TitleLinkButton>();
 
    public static string versionNumber = "v1.4.4.9";
 
    public static string versionNumber2 = "v1.4.4.9";
 
    public static bool AnnouncementBoxDisabled;
 
    public static int AnnouncementBoxRange = -1;
 
    public static string AutogenSeedName;
 
    private static GameModeData _currentGameModeInfo = GameModeData.NormalMode;
 
    public static Dictionary<int, GameModeData> RegisteredGameModes = new Dictionary<int, GameModeData>
    {
        {
            0,
            GameModeData.NormalMode
        },
        {
            1,
            GameModeData.ExpertMode
        },
        {
            2,
            GameModeData.MasterMode
        },
        {
            3,
            GameModeData.CreativeMode
        }
    };
 
    private static bool? _overrideForExpertMode = null;
 
    private static bool? _overrideForMasterMode = null;
 
    public static bool drunkWorld = false;
 
    public static bool getGoodWorld = false;
 
    public static bool tenthAnniversaryWorld = false;
 
    public static bool dontStarveWorld = false;
 
    public static bool notTheBeesWorld = false;
 
    public static bool remixWorld = false;
 
    public static bool noTrapsWorld = false;
 
    public static bool zenithWorld = false;
 
    public static Vector2 destroyerHB = new Vector2(0f, 0f);
 
    public static FavoritesFile LocalFavoriteData = new FavoritesFile(SavePath + "/favorites.json", isCloud: false);
 
    public static FavoritesFile CloudFavoritesData = new FavoritesFile("favorites.json", isCloud: true);
 
    public static FileMetadata WorldFileMetadata;
 
    public static FileMetadata MapFileMetadata;
 
    public static PingMapLayer Pings = new PingMapLayer();
 
    public static MapIconOverlay MapIcons = new MapIconOverlay().AddLayer(new SpawnMapLayer()).AddLayer(new TeleportPylonsMapLayer()).AddLayer(Pings);
 
    public static CreativeUI CreativeMenu = new CreativeUI();
 
    private static Vector2 _lastPingMousePosition = Vector2.Zero;
 
    private static double _lastPingMouseDownTime = 0.0;
 
    private AchievementManager _achievements;
 
    private AchievementAdvisor _achievementAdvisor;
 
    public static BigProgressBarSystem BigBossProgressBar = new BigProgressBarSystem();
 
    public static UserInterface MenuUI = new UserInterface();
 
    public static UserInterface InGameUI = new UserInterface();
 
    private static OnPlayerSelected _pendingCharacterSelect;
 
    public static bool drawBackGore;
 
    public static ulong LobbyId = 0uL;
 
    private static Microsoft.Xna.Framework.Color[] _mapColorCacheArray = new Microsoft.Xna.Framework.Color[30000];
 
    public WaterfallManager waterfallManager;
 
    public static WorldSections sectionManager;
 
    public static bool ServerSideCharacter;
 
    public static string clientUUID;
 
    public static bool ContentLoaded = false;
 
    private static int toolTipDistance = 6;
 
    public static float GlobalTimeWrappedHourly;
 
    public static bool GlobalTimerPaused = false;
 
    public static GameTime gameTimeCache = new GameTime();
 
    public static ulong TileFrameSeed = (ulong)Guid.NewGuid().GetHashCode();
 
    private static ulong _drawCycleCounter;
 
    public static ContentManager ShaderContentManager;
 
    public static Ref<Effect> ScreenShaderRef = new Ref<Effect>();
 
    public static Ref<Effect> PixelShaderRef = new Ref<Effect>();
 
    public static Ref<Effect> TileShaderRef = new Ref<Effect>();
 
    public static Ref<Effect> VertexPixelShaderRef = new Ref<Effect>();
 
    public static int WaveQuality = 3;
 
    public static bool UseStormEffects = true;
 
    public static bool UseHeatDistortion = true;
 
    public static List<IEnumerator> DelayedProcesses = new List<IEnumerator>();
 
    public static int npcStreamSpeed = 30;
 
    public static int musicError;
 
    public static bool dedServFPS;
 
    public static int dedServCount1;
 
    public static int dedServCount2;
 
    public static bool superFast = false;
 
    public static readonly int offLimitBorderTiles = 40;
 
    public static readonly int maxMusic = 92;
 
    public const int MaxBannerTypes = 290;
 
    public static readonly int maxBackgrounds = 298;
 
    public const int MaxShopIDs = 100;
 
    private static float cameraLerp;
 
    private static int cameraLerpTimer;
 
    private static int cameraLerpTimeToggle;
 
    private static bool cameraGamePadLerp;
 
    public static Vector2[] OffsetsNPCOffhand = new Vector2[5]
    {
        new Vector2(14f, 34f),
        new Vector2(14f, 32f),
        new Vector2(14f, 26f),
        new Vector2(14f, 22f),
        new Vector2(14f, 18f)
    };
 
    public static Vector2[] OffsetsPlayerOffhand = new Vector2[20]
    {
        new Vector2(14f, 20f),
        new Vector2(14f, 20f),
        new Vector2(14f, 20f),
        new Vector2(14f, 18f),
        new Vector2(14f, 20f),
        new Vector2(16f, 4f),
        new Vector2(16f, 16f),
        new Vector2(18f, 14f),
        new Vector2(18f, 14f),
        new Vector2(18f, 14f),
        new Vector2(16f, 16f),
        new Vector2(16f, 16f),
        new Vector2(16f, 16f),
        new Vector2(16f, 16f),
        new Vector2(14f, 14f),
        new Vector2(14f, 14f),
        new Vector2(12f, 14f),
        new Vector2(14f, 16f),
        new Vector2(16f, 16f),
        new Vector2(16f, 16f)
    };
 
    public static Vector2[] OffsetsPlayerOnhand = new Vector2[20]
    {
        new Vector2(6f, 19f),
        new Vector2(5f, 10f),
        new Vector2(12f, 10f),
        new Vector2(13f, 17f),
        new Vector2(12f, 19f),
        new Vector2(5f, 10f),
        new Vector2(7f, 17f),
        new Vector2(6f, 16f),
        new Vector2(6f, 16f),
        new Vector2(6f, 16f),
        new Vector2(6f, 17f),
        new Vector2(7f, 17f),
        new Vector2(7f, 17f),
        new Vector2(7f, 17f),
        new Vector2(8f, 17f),
        new Vector2(9f, 16f),
        new Vector2(9f, 12f),
        new Vector2(8f, 17f),
        new Vector2(7f, 17f),
        new Vector2(7f, 17f)
    };
 
    public static Vector2[] OffsetsPlayerHeadgear = new Vector2[20]
    {
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 0f),
        new Vector2(0f, 0f),
        new Vector2(0f, 0f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 0f),
        new Vector2(0f, 0f),
        new Vector2(0f, 0f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f),
        new Vector2(0f, 2f)
    };
 
    public static Vector2 CurrentPan = Vector2.Zero;
 
    public static float sunCircle;
 
    public static int BlackFadeIn;
 
    public static bool noWindowBorder = false;
 
    public static RasterizerState Rasterizer = RasterizerState.CullCounterClockwise;
 
    private string _cachedTitle;
 
    public static int undergroundBackground;
 
    public static int oldUndergroundBackground;
 
    public static bool skipMenu = false;
 
    public static bool verboseNetplay = false;
 
    public static bool stopTimeOuts = false;
 
    public static bool showSpam = false;
 
    public static bool showItemOwner = false;
 
    public static bool[] townNPCCanSpawn = new bool[NPCID.Count];
 
    public static int musicBox2 = -1;
 
    public static int musicBoxNotModifiedByVolume = -1;
 
    public static byte HealthBarDrawSettings = 1;
 
    public static bool runningCollectorsEdition;
 
    public static float wFrCounter;
 
    public static float wFrame;
 
    public static float upTimer;
 
    public static float upTimerMax;
 
    public static float upTimerMaxDelay;
 
    public static bool drawDiag;
 
    public static bool drawRelease;
 
    public static bool drawBetterDebug;
 
    public static bool betterDebugRelease;
 
    public static bool renderNow;
 
    public static bool drawToScreen;
 
    public static bool targetSet;
 
    public static int mouseX;
 
    public static int mouseY;
 
    public static int lastMouseX;
 
    public static int lastMouseY;
 
    private static ConcurrentQueue<Action> _mainThreadActions = new ConcurrentQueue<Action>();
 
    public static bool mouseLeft;
 
    public static bool mouseRight;
 
    public static bool isMouseLeftConsumedByUI = false;
 
    public static float essScale = 1f;
 
    public static int essDir = -1;
 
    public static float[] cloudBGX = new float[2];
 
    public static float cloudBGAlpha;
 
    public static float cloudBGActive;
 
    public static int[] cloudBG = new int[2] { 112, 113 };
 
    public static int[] treeMntBGSet1 = new int[2];
 
    public static int[] treeMntBGSet2 = new int[2];
 
    public static int[] treeMntBGSet3 = new int[2];
 
    public static int[] treeMntBGSet4 = new int[2];
 
    public static int[] treeBGSet1 = new int[3];
 
    public static int[] treeBGSet2 = new int[3];
 
    public static int[] treeBGSet3 = new int[3];
 
    public static int[] treeBGSet4 = new int[3];
 
    public static int[] corruptBG = new int[3];
 
    public static int[] jungleBG = new int[3];
 
    public static int[] snowMntBG = new int[2];
 
    public static int[] snowBG = new int[3];
 
    public static int[] hallowBG = new int[3];
 
    public static int[] crimsonBG = new int[3];
 
    public static int[] desertBG = new int[3];
 
    public static int[] mushroomBG = new int[3];
 
    public static int oceanBG;
 
    public static int[] underworldBG = new int[5];
 
    public static int[] treeX = new int[4];
 
    public static int[] treeStyle = new int[4];
 
    public static int[] caveBackX = new int[4];
 
    public static int[] caveBackStyle = new int[4];
 
    public static int iceBackStyle;
 
    public static int hellBackStyle;
 
    public static int jungleBackStyle;
 
    public static string debugWords = "";
 
    public static bool gamePad = false;
 
    public static bool xMas;
 
    public static bool halloween;
 
    public static bool forceXMasForToday;
 
    public static bool forceHalloweenForToday;
 
    public static bool DisableIntenseVisualEffects = false;
 
    public static int snowDust = 0;
 
    public static bool changeTheTitle;
 
    public static bool hairWindow;
 
    public static bool clothesWindow;
 
    public static bool ingameOptionsWindow = false;
 
    public static bool inFancyUI = false;
 
    public static int keyCount;
 
    public static string[] keyString = new string[10];
 
    public static int[] keyInt = new int[10];
 
    public static byte gFade;
 
    public static float gFader;
 
    public static byte gFadeDir = 1;
 
    public static bool shouldDrawNetDiagnosticsUI;
 
    private static INetDiagnosticsUI _activeNetDiagnosticsUI;
 
    public static IMultiplayerClosePlayersOverlay ActiveClosePlayersTeamOverlay = new NewMultiplayerClosePlayersOverlay();
 
    public static double UpdateTimeAccumulator;
 
    public static bool drawSkip;
 
    public static int fpsCount;
 
    public static Stopwatch fpsTimer = new Stopwatch();
 
    public bool gammaTest;
 
    private const bool USE_ASYNC_LOAD = true;
 
    private static bool _isAsyncLoadComplete;
 
    public static bool showSplash = true;
 
    public static bool ignoreErrors = true;
 
    public static string defaultIP = "";
 
    public static int dayRate = 1;
 
    public static int desiredWorldTilesUpdateRate = 1;
 
    public static int maxScreenW = 1920;
 
    public static int maxScreenH = 1200;
 
    public static int minScreenW = 800;
 
    public static int minScreenH = 600;
 
    public static float iS = 1f;
 
    public static bool render;
 
    public static int qaStyle;
 
    public static int buffScanAreaWidth = (maxScreenW + 800) / 16 - 1;
 
    public static int buffScanAreaHeight = (maxScreenH + 800) / 16 - 1;
 
    public static float musicPitch = 0f;
 
    public static bool[] projHostile = new bool[ProjectileID.Count];
 
    public static bool[] projHook = new bool[ProjectileID.Count];
 
    public static bool[] pvpBuff = new bool[BuffID.Count];
 
    public static bool[] persistentBuff = new bool[BuffID.Count];
 
    public static bool[] vanityPet = new bool[BuffID.Count];
 
    public static bool[] lightPet = new bool[BuffID.Count];
 
    public static bool[] meleeBuff = new bool[BuffID.Count];
 
    public static bool[] debuff = new bool[BuffID.Count];
 
    public static bool[] buffNoSave = new bool[BuffID.Count];
 
    public static bool[] buffNoTimeDisplay = new bool[BuffID.Count];
 
    public static bool[] buffDoubleApply = new bool[BuffID.Count];
 
    public static int maxMP = 10;
 
    public static string[] recentWorld = new string[maxMP];
 
    public static string[] recentIP = new string[maxMP];
 
    public static int[] recentPort = new int[maxMP];
 
    public static bool shortRender = true;
 
    public static bool BackgroundEnabled = true;
 
    public static int instantBGTransitionCounter = 2;
 
    public static int bgDelay;
 
    public static int bgStyle;
 
    private const int BG_STYLES_COUNT = 14;
 
    public static float[] bgAlphaFrontLayer = new float[14];
 
    public static float[] bgAlphaFarBackLayer = new float[14];
 
    public static int[] bgFrame = new int[14];
 
    public static int[] bgFrameCounter = new int[14];
 
    public static int EquipPage;
 
    public static int EquipPageSelected;
 
    public int mouseNPCIndex = -1;
 
    public int mouseNPCType = -1;
 
    public static int wofNPCIndex = -1;
 
    public static int wofDrawAreaTop;
 
    public static int wofDrawAreaBottom;
 
    public static int wofDrawFrameIndex;
 
    public static int offScreenRange = 200;
 
    private RenderTarget2D backWaterTarget;
 
    public static RenderTarget2D waterTarget;
 
    private RenderTarget2D tileTarget;
 
    private RenderTarget2D blackTarget;
 
    private RenderTarget2D tile2Target;
 
    private RenderTarget2D wallTarget;
 
    private RenderTarget2D backgroundTarget;
 
    public static RenderTarget2D screenTarget;
 
    public static RenderTarget2D screenTargetSwap;
 
    public static int maxMapUpdates = 250000;
 
    public static bool refreshMap;
 
    public static int loadMapLastX;
 
    public static bool loadMapLock;
 
    public static bool loadMap;
 
    public static bool mapReady;
 
    public static int textureMaxWidth = 2000;
 
    public static int textureMaxHeight = 1800;
 
    public static bool updateMap;
 
    public static int mapMinX = 0;
 
    public static int mapMaxX = 0;
 
    public static int mapMinY;
 
    public static int mapMaxY;
 
    public static int mapTimeMax = 30;
 
    public static int mapTime = mapTimeMax;
 
    public static bool clearMap;
 
    public static int mapTargetX = 5;
 
    public static int mapTargetY = 2;
 
    private RenderTarget2D[,] mapTarget = new RenderTarget2D[mapTargetX, mapTargetY];
 
    private RenderTarget2D mapSectionTexture;
 
    public static bool[,] initMap = new bool[mapTargetX, mapTargetY];
 
    public static bool[,] mapWasContentLost = new bool[mapTargetX, mapTargetY];
 
    public const int numInfoIcons = 13;
 
    public static Microsoft.Xna.Framework.Color OurFavoriteColor = new Microsoft.Xna.Framework.Color(255, 231, 69);
 
    public static bool mapInit;
 
    public static bool mapEnabled = true;
 
    public static int mapStyle = 1;
 
    public static float grabMapX;
 
    public static float grabMapY;
 
    public static int miniMapX;
 
    public static int miniMapY;
 
    public static int miniMapWidth;
 
    public static int miniMapHeight;
 
    public static float mapMinimapDefaultScale = 1.05f;
 
    public static float mapMinimapScale = mapMinimapDefaultScale;
 
    public static float mapMinimapAlpha = 1f;
 
    public static float mapOverlayScale = 2.5f;
 
    public static float mapOverlayAlpha = 0.35f;
 
    public static bool mapFullscreen;
 
    public static bool resetMapFull;
 
    public static float mapFullscreenScale = 4f;
 
    public static Vector2 mapFullscreenPos = new Vector2(-1f, -1f);
 
    private static bool IsEnginePreloaded;
 
    private static bool IsEngineLoaded;
 
    private static uint _gameUpdateCount;
 
    public static bool SkipAssemblyLoad;
 
    private int firstTileX;
 
    private int lastTileX;
 
    private int firstTileY;
 
    private int lastTileY;
 
    private double bgParallax;
 
    private int bgStartX;
 
    private int bgLoops;
 
    private int bgStartY;
 
    private int bgLoopsY;
 
    private int bgTopY;
 
    public static int renderCount = 99;
 
    private const int MF_BYPOSITION = 1024;
 
    public static GraphicsDeviceManager graphics;
 
    public static SpriteBatch spriteBatch;
 
    public static TileBatch tileBatch;
 
    public static BasicDebugDrawer DebugDrawer;
 
    public static SamplerState SamplerStateForCursor = SamplerState.LinearClamp;
 
    public static GenerationProgress AutogenProgress = new GenerationProgress();
 
    private static Process tServer;
 
    private static Stopwatch saveTime = new Stopwatch();
 
    public static KeyboardState keyState;
 
    public static KeyboardState oldKeyState;
 
    public static Microsoft.Xna.Framework.Color mcColor = new Microsoft.Xna.Framework.Color(1f, 0.6f, 0f);
 
    public static Microsoft.Xna.Framework.Color hcColor = new Microsoft.Xna.Framework.Color(1f, 0.15f, 0.1f);
 
    public static Microsoft.Xna.Framework.Color creativeModeColor = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.HotPink, Microsoft.Xna.Framework.Color.White, 0.1f);
 
    public static Microsoft.Xna.Framework.Color legendaryModeColor = Microsoft.Xna.Framework.Color.LimeGreen;
 
    public static Microsoft.Xna.Framework.Color highVersionColor = new Microsoft.Xna.Framework.Color(255, 255, 0);
 
    public static Microsoft.Xna.Framework.Color errorColor = new Microsoft.Xna.Framework.Color(255, 0, 0);
 
    public static bool craftingHide;
 
    public static bool armorHide;
 
    public static float shimmerAlpha = 0f;
 
    public static float shimmerDarken = 0f;
 
    public static float shimmerBrightenDelay = 0f;
 
    public static float craftingAlpha = 1f;
 
    public static float armorAlpha = 1f;
 
    public static float[] buffAlpha = new float[BuffID.Count];
 
    public static bool afterPartyOfDoom = false;
 
    public static bool hardMode;
 
    public float chestLootScale = 1f;
 
    public bool chestLootHover;
 
    public float chestStackScale = 1f;
 
    public bool chestStackHover;
 
    public float chestDepositScale = 1f;
 
    public bool chestDepositHover;
 
    public float chestRenameScale = 1f;
 
    public bool chestRenameHover;
 
    public float chestCancelScale = 1f;
 
    public bool chestCancelHover;
 
    public static Vector2 sceneWaterPos = Vector2.Zero;
 
    public static Vector2 sceneTilePos = Vector2.Zero;
 
    public static Vector2 sceneTile2Pos = Vector2.Zero;
 
    public static Vector2 sceneWallPos = Vector2.Zero;
 
    public static Vector2 sceneBackgroundPos = Vector2.Zero;
 
    public static bool maxQ = true;
 
    public static float gfxQuality = 1f;
 
    public static float gfxRate = 0.01f;
 
    public int DiscoStyle;
 
    public static int DiscoR = 255;
 
    public static int DiscoB;
 
    public static int DiscoG;
 
    public static int teamCooldown;
 
    public static int teamCooldownLen = 300;
 
    public static bool gamePaused;
 
    public static bool gameInactive;
 
    public static int updatesCountedForFPS;
 
    public static int drawsCountedForFPS;
 
    public static int uCount;
 
    public static int updateRate;
 
    public static int frameRate;
 
    public static bool RGBRelease;
 
    public static bool qRelease = false;
 
    public static bool netRelease;
 
    public static bool frameRelease;
 
    public static bool showFrameRate = false;
 
    public static int magmaBGFrame;
 
    public static int magmaBGFrameCounter;
 
    public static int saveTimer = 0;
 
    public static bool autoJoin;
 
    public static bool serverStarting = false;
 
    public static float leftWorld = 0f;
 
    public static float rightWorld = 134400f;
 
    public static float topWorld = 0f;
 
    public static float bottomWorld = 38400f;
 
    public static int maxTilesX = (int)rightWorld / 16 + 1;
 
    public static int maxTilesY = (int)bottomWorld / 16 + 1;
 
    public const int sectionWidth = 200;
 
    public const int sectionHeight = 150;
 
    public static int maxSectionsX = maxTilesX / 200;
 
    public static int maxSectionsY = maxTilesY / 150;
 
    public const int maxDust = 6000;
 
    public static int maxDustToDraw = 6000;
 
    public const int maxCombatText = 100;
 
    public const int maxItemText = 20;
 
    public const int maxPlayers = 255;
 
    public static int maxNetPlayers = 255;
 
    public const int maxChests = 8000;
 
    public const int maxItems = 400;
 
    public const int maxProjectiles = 1000;
 
    public const int maxNPCs = 200;
 
    private static UICharacterSelect _characterSelectMenu = new UICharacterSelect();
 
    private static UIWorldSelect _worldSelectMenu = new UIWorldSelect();
 
    public static UIManageControls ManageControlsMenu = new UIManageControls();
 
    public static UIAchievementsMenu AchievementsMenu = new UIAchievementsMenu();
 
    public static int maxRain = 750;
 
    public static int slimeWarningTime;
 
    public static int slimeWarningDelay = 420;
 
    public static float slimeRainNPCSlots = 0.65f;
 
    public static bool[] slimeRainNPC = new bool[NPCID.Count];
 
    public static double slimeRainTime;
 
    public static bool slimeRain;
 
    public static int slimeRainKillCount;
 
    private const double slimeRainMaxTime = 54000.0;
 
    private const double slimeRainMinTime = 32400.0;
 
    private const double slimeRainMaxDelay = 604800.0;
 
    private const double slimeRainMinDelay = 302400.0;
 
    private const double LeinforsBalanceRequestForSlimeRainChance = 1.0416666666666667;
 
    private const double slimeRainChance = 450000.00000000006;
 
    public const int maxGore = 600;
 
    public const int InventoryItemSlotsStart = 0;
 
    public const int InventoryItemSlotsCount = 50;
 
    public const int InventoryCoinSlotsStart = 50;
 
    public const int InventoryCoinSlotsCount = 4;
 
    public const int InventoryAmmoSlotsStart = 54;
 
    public const int InventoryAmmoSlotsCount = 4;
 
    public const int InventorySlotsTotal = 58;
 
    public int invBottom = 210;
 
    public const int maxLiquidTypes = 15;
 
    public static float cameraX;
 
    public static bool drewLava;
 
    public static float[] liquidAlpha = new float[15];
 
    public static int waterStyle;
 
    public static int WorldRollingBackupsCountToKeep = 2;
 
    private static bool TOWMusicUnlocked = false;
 
    private static bool swapMusic = false;
 
    public static float caveParallax = 0.88f;
 
    public static int dungeonX;
 
    public static int dungeonY;
 
    public static Liquid[] liquid = new Liquid[Liquid.maxLiquid];
 
    public static LiquidBuffer[] liquidBuffer = new LiquidBuffer[50000];
 
    public static bool dedServ;
 
    public static int spamCount = 0;
 
    public static int curMusic;
 
    public static int dayMusic;
 
    public static int ugMusic;
 
    public static int newMusic;
 
    public static bool showItemText = true;
 
    public static bool autoSave = true;
 
    public static bool validateSaves = true;
 
    public static bool bannerMouseOver;
 
    public static string buffString = "";
 
    public static string libPath = "";
 
    public static int lo;
 
    public static int LogoA = 255;
 
    public static int LogoB;
 
    public static bool LogoT;
 
    public static string statusText = "";
 
    public static string worldName = "";
 
    public static int worldID;
 
    public static int background;
 
    public static int caveBackground = 0;
 
    public static float ugBackTransition;
 
    public static Microsoft.Xna.Framework.Color tileColor;
 
    public static double worldSurface;
 
    public static double rockLayer;
 
    public static Microsoft.Xna.Framework.Color[] teamColor = new Microsoft.Xna.Framework.Color[6];
 
    public const double dayLength = 54000.0;
 
    public const double nightLength = 32400.0;
 
    public static bool dayTime = true;
 
    public static double time = 13500.0;
 
    public static double timeForVisualEffects;
 
    public static int moonPhase;
 
    public static short sunModY;
 
    public static short moonModY;
 
    public static bool alreadyGrabbingSunOrMoon;
 
    public static bool bloodMoon;
 
    public static bool pumpkinMoon;
 
    public static bool snowMoon;
 
    public static float cloudAlpha;
 
    public static float maxRaining;
 
    public static float oldMaxRaining;
 
    public static int rainTime;
 
    public static bool raining;
 
    public static bool eclipse;
 
    public static float eclipseLight;
 
    public static int checkForSpawns;
 
    public static int helpText;
 
    public static int BartenderHelpTextIndex = 0;
 
    public static bool autoGen;
 
    public static bool autoPause = false;
 
    public static int[] projFrames = new int[ProjectileID.Count];
 
    public static bool[] projPet = new bool[ProjectileID.Count];
 
    public static float demonTorch = 1f;
 
    public static int demonTorchDir = 1;
 
    public static float martianLight = 1f;
 
    public static int martianLightDir = 1;
 
    public static float masterColor = 1f;
 
    public static int masterColorDir = 1;
 
    public static bool placementPreview = true;
 
    public static SceneMetrics SceneMetrics;
 
    public const int maxStars = 400;
 
    public static int numStars;
 
    public const int maxStarTypes = 4;
 
    public const int maxClouds = 200;
 
    public static int weatherCounter;
 
    public static int numClouds = 200;
 
    public static int numCloudsTemp = numClouds;
 
    public static float windSpeedCurrent;
 
    public static float windSpeedTarget;
 
    public static int windCounter;
 
    public static int extremeWindCounter;
 
    public static bool windPhysics = false;
 
    public static float windPhysicsStrength = 0.1f;
 
    public static bool SettingsEnabled_TilesSwayInWind = true;
 
    public static Cloud[] cloud = new Cloud[200];
 
    public static bool resetClouds = true;
 
    public static float SmoothedMushroomLightInfluence;
 
    public static int fadeCounter;
 
    public static float invAlpha = 1f;
 
    public static float invDir = 1f;
 
    [ThreadStatic]
    public static UnifiedRandom rand;
 
    public static bool allChestStackHover;
 
    public static bool inventorySortMouseOver;
 
    public static float GraveyardVisualIntensity;
 
    public const int maxMoons = 9;
 
    public static int moonType = 0;
 
    public const int numTileColors = 32;
 
    public const int numTreeStyles = 32;
 
    public const int numberOfHairstyles = 165;
 
    public const int maxHairStyles = 165;
 
    public const int maxCharSelectHair = 51;
 
    public const int maxHairOfStylistDefault = 123;
 
    public static bool UseExperimentalFeatures;
 
    public static string DefaultSeed = "";
 
    public static IAudioSystem audioSystem;
 
    public static bool[] musicNoCrossFade = new bool[maxMusic];
 
    public static float[] musicFade = new float[maxMusic];
 
    public static float musicVolume = 1f;
 
    public static float ambientVolume = 1f;
 
    public static float soundVolume = 1f;
 
    public static ServerMode MenuServerMode = ServerMode.Lobby | ServerMode.FriendsCanJoin;
 
    public static bool[] tileLighted = new bool[TileID.Count];
 
    public static bool[] tileMergeDirt = new bool[TileID.Count];
 
    public static bool[] tileCut = new bool[TileID.Count];
 
    public static bool[] tileAlch = new bool[TileID.Count];
 
    public static int[] tileShine = new int[TileID.Count];
 
    public static bool[] tileShine2 = new bool[TileID.Count];
 
    public static bool[] wallHouse = new bool[WallID.Count];
 
    public static bool[] wallDungeon = new bool[WallID.Count];
 
    public static bool[] wallLight = new bool[WallID.Count];
 
    public static int[] wallBlend = new int[WallID.Count];
 
    public static bool[] tileStone = new bool[TileID.Count];
 
    public static bool[] tileAxe = new bool[TileID.Count];
 
    public static bool[] tileHammer = new bool[TileID.Count];
 
    public static bool[] tileWaterDeath = new bool[TileID.Count];
 
    public static bool[] tileLavaDeath = new bool[TileID.Count];
 
    public static bool[] tileTable = new bool[TileID.Count];
 
    public static bool[] tileBlockLight = new bool[TileID.Count];
 
    public static bool[] tileNoSunLight = new bool[TileID.Count];
 
    public static bool[] tileDungeon = new bool[TileID.Count];
 
    public static bool[] tileSpelunker = new bool[TileID.Count];
 
    public static bool[] tileSolidTop = new bool[TileID.Count];
 
    public static bool[] tileSolid = new bool[TileID.Count];
 
    public static bool[] tileBouncy = new bool[TileID.Count];
 
    public static short[] tileOreFinderPriority = new short[TileID.Count];
 
    public static byte[] tileLargeFrames = new byte[TileID.Count];
 
    public static byte[] wallLargeFrames = new byte[WallID.Count];
 
    public static bool[] tileRope = new bool[TileID.Count];
 
    public static bool[] tileBrick = new bool[TileID.Count];
 
    public static bool[] tileMoss = new bool[TileID.Count];
 
    public static bool[] tileNoAttach = new bool[TileID.Count];
 
    public static bool[] tileNoFail = new bool[TileID.Count];
 
    public static bool[] tileCracked = new bool[TileID.Count];
 
    public static bool[] tileObsidianKill = new bool[TileID.Count];
 
    public static bool[] tileFrameImportant = new bool[TileID.Count];
 
    public static bool[] tilePile = new bool[TileID.Count];
 
    public static bool[] tileBlendAll = new bool[TileID.Count];
 
    public static short[] tileGlowMask = new short[TileID.Count];
 
    public static bool[] tileContainer = new bool[TileID.Count];
 
    public static bool[] tileSign = new bool[TileID.Count];
 
    public static bool[][] tileMerge = new bool[TileID.Count][];
 
    public static int cageFrames = 25;
 
    public static bool critterCage;
 
    public static int[] bunnyCageFrame = new int[cageFrames];
 
    public static int[] bunnyCageFrameCounter = new int[cageFrames];
 
    public static int[] squirrelCageFrame = new int[cageFrames];
 
    public static int[] squirrelCageFrameCounter = new int[cageFrames];
 
    public static int[] squirrelCageFrameOrange = new int[cageFrames];
 
    public static int[] squirrelCageFrameCounterOrange = new int[cageFrames];
 
    public static int[] mallardCageFrame = new int[cageFrames];
 
    public static int[] mallardCageFrameCounter = new int[cageFrames];
 
    public static int[] duckCageFrame = new int[cageFrames];
 
    public static int[] duckCageFrameCounter = new int[cageFrames];
 
    public static int[] grebeCageFrame = new int[cageFrames];
 
    public static int[] grebeCageFrameCounter = new int[cageFrames];
 
    public static int[] seagullCageFrame = new int[cageFrames];
 
    public static int[] seagullCageFrameCounter = new int[cageFrames];
 
    public static int[] birdCageFrame = new int[cageFrames];
 
    public static int[] birdCageFrameCounter = new int[cageFrames];
 
    public static int[] redBirdCageFrame = new int[cageFrames];
 
    public static int[] redBirdCageFrameCounter = new int[cageFrames];
 
    public static int[] blueBirdCageFrame = new int[cageFrames];
 
    public static int[] blueBirdCageFrameCounter = new int[cageFrames];
 
    public static int[] macawCageFrame = new int[cageFrames];
 
    public static int[] macawCageFrameCounter = new int[cageFrames];
 
    public static byte[,] butterflyCageMode = new byte[9, cageFrames];
 
    public static int[,] butterflyCageFrame = new int[9, cageFrames];
 
    public static int[,] butterflyCageFrameCounter = new int[9, cageFrames];
 
    public static int[,] dragonflyJarFrameCounter = new int[7, cageFrames];
 
    public static int[,] dragonflyJarFrame = new int[7, cageFrames];
 
    public static int[,] scorpionCageFrame = new int[2, cageFrames];
 
    public static int[,] scorpionCageFrameCounter = new int[2, cageFrames];
 
    public static int[] snailCageFrame = new int[cageFrames];
 
    public static int[] snailCageFrameCounter = new int[cageFrames];
 
    public static int[] snail2CageFrame = new int[cageFrames];
 
    public static int[] snail2CageFrameCounter = new int[cageFrames];
 
    public static byte[] fishBowlFrameMode = new byte[cageFrames];
 
    public static int[] fishBowlFrame = new int[cageFrames];
 
    public static int[] fishBowlFrameCounter = new int[cageFrames];
 
    public static int[] lavaFishBowlFrame = new int[cageFrames];
 
    public static int[] lavaFishBowlFrameCounter = new int[cageFrames];
 
    public static int[] frogCageFrame = new int[cageFrames];
 
    public static int[] frogCageFrameCounter = new int[cageFrames];
 
    public static int[] mouseCageFrame = new int[cageFrames];
 
    public static int[] mouseCageFrameCounter = new int[cageFrames];
 
    public static int[] turtleCageFrame = new int[cageFrames];
 
    public static int[] turtleCageFrameCounter = new int[cageFrames];
 
    public static int[] fairyJarFrame = new int[cageFrames];
 
    public static int[] fairyJarFrameCounter = new int[cageFrames];
 
    public static byte[,] jellyfishCageMode = new byte[3, cageFrames];
 
    public static int[,] jellyfishCageFrame = new int[3, cageFrames];
 
    public static int[,] jellyfishCageFrameCounter = new int[3, cageFrames];
 
    public static int[] wormCageFrame = new int[cageFrames];
 
    public static int[] wormCageFrameCounter = new int[cageFrames];
 
    public static int[] maggotCageFrame = new int[cageFrames];
 
    public static int[] maggotCageFrameCounter = new int[cageFrames];
 
    public static int[] ratCageFrame = new int[cageFrames];
 
    public static int[] ratCageFrameCounter = new int[cageFrames];
 
    public static int[] ladybugCageFrame = new int[cageFrames];
 
    public static int[] ladybugCageFrameCounter = new int[cageFrames];
 
    public static int[] penguinCageFrame = new int[cageFrames];
 
    public static int[] penguinCageFrameCounter = new int[cageFrames];
 
    public static int[] waterStriderCageFrame = new int[cageFrames];
 
    public static int[] waterStriderCageFrameCounter = new int[cageFrames];
 
    public static int[] seahorseCageFrame = new int[cageFrames];
 
    public static int[] seahorseCageFrameCounter = new int[cageFrames];
 
    public static int[,] slugCageFrame = new int[3, cageFrames];
 
    public static int[,] slugCageFrameCounter = new int[3, cageFrames];
 
    public static int[] owlCageFrame = new int[cageFrames];
 
    public static int[] owlCageFrameCounter = new int[cageFrames];
 
    public static int[] grasshopperCageFrame = new int[cageFrames];
 
    public static int[] grasshopperCageFrameCounter = new int[cageFrames];
 
    public static bool[] tileSand = new bool[TileID.Count];
 
    public static bool[] tileFlame = new bool[TileID.Count];
 
    public static bool[] npcCatchable = new bool[NPCID.Count];
 
    public static int[] tileFrame = new int[TileID.Count];
 
    public static int[] tileFrameCounter = new int[TileID.Count];
 
    public static byte[] wallFrame = new byte[WallID.Count];
 
    public static byte[] wallFrameCounter = new byte[WallID.Count];
 
    public static int[] backgroundWidth = new int[maxBackgrounds];
 
    public static int[] backgroundHeight = new int[maxBackgrounds];
 
    public static HairstyleUnlocksHelper Hairstyles = new HairstyleUnlocksHelper();
 
    public static bool tilesLoaded = false;
 
    public static WorldMap Map;
 
    public static Tile[,] tile = new Tile[maxTilesX, maxTilesY];
 
    public static Dust[] dust = new Dust[6001];
 
    public static Star[] star = new Star[400];
 
    public static Item[] item = new Item[401];
 
    public static int[] timeItemSlotCannotBeReusedFor = new int[401];
 
    public static NPC[] npc = new NPC[201];
 
    public static Gore[] gore = new Gore[601];
 
    public static Rain[] rain = new Rain[maxRain + 1];
 
    public static Projectile[] projectile = new Projectile[1001];
 
    public static int[,] projectileIdentity = new int[256, 1001];
 
    public static CombatText[] combatText = new CombatText[100];
 
    public static PopupText[] popupText = new PopupText[20];
 
    public static Chest[] chest = new Chest[8000];
 
    public static Sign[] sign = new Sign[1000];
 
    public static int[] itemFrame = new int[401];
 
    public static int[] itemFrameCounter = new int[401];
 
    public static DrawAnimation[] itemAnimations = new DrawAnimation[ItemID.Count];
 
    private static DrawAnimation _coinOnWorldAnimation = new DrawAnimationVertical(6, 8);
 
    private static DrawAnimation _monkStaffT3OnWorldAnimation = new DrawAnimationVertical(5, 3);
 
    public static List<int> itemAnimationsRegistered = new List<int>();
 
    public static Vector2 screenPosition;
 
    public static Vector2 screenLastPosition;
 
    public static int screenWidth = 1152;
 
    public static int screenHeight = 864;
 
    public static bool screenMaximized = true;
 
    public static bool screenBorderless = true;
 
    public static int screenBorderlessPendingResizes;
 
    public static int teamNamePlateDistance = 2000;
 
    public static int multiplayerNPCSmoothingRange = 300;
 
    public static bool Setting_UseReducedMaxLiquids = false;
 
    public static int PlayerOverheadChatMessageDisplayTime = 400;
 
    public static object CurrentInputTextTakerOverride;
 
    public static bool drawingPlayerChat;
 
    public static bool chatRelease;
 
    public static string chatText = "";
 
    public static bool inputTextEnter;
 
    public static bool inputTextEscape;
 
    public static float[] hotbarScale = new float[10] { 1f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f, 0.75f };
 
    public static byte mouseTextColor;
 
    public static int mouseTextColorChange = 1;
 
    public static bool mouseLeftRelease;
 
    public static bool mouseRightRelease;
 
    public static bool playerInventory;
 
    public static int stackSplit;
 
    public static bool preventStackSplitReset;
 
    public static int stackCounter;
 
    public static int timesTriedToFastStack;
 
    public static int stackDelay = 7;
 
    public static int superFastStack;
 
    public static Item mouseItem = new Item();
 
    public static Item guideItem = new Item();
 
    public static Item reforgeItem = new Item();
 
    public static float inventoryScale = 0.75f;
 
    public static bool hasFocus;
 
    public static Microsoft.Xna.Framework.Point rulerLineDisplayValues = default(Microsoft.Xna.Framework.Point);
 
    public static bool recFastScroll;
 
    public static bool recBigList;
 
    public static int recStart;
 
    public static Recipe[] recipe = new Recipe[Recipe.maxRecipes];
 
    public static int[] availableRecipe = new int[Recipe.maxRecipes];
 
    public static float[] availableRecipeY = new float[Recipe.maxRecipes];
 
    public static int numAvailableRecipes;
 
    public static int focusRecipe;
 
    public static int myPlayer;
 
    public static Player[] player = new Player[256];
 
    public static Player[] playerVisualClone = new Player[256];
 
    public static bool[] countsAsHostForGameplay = new bool[256];
 
    public static int spawnTileX;
 
    public static int spawnTileY;
 
    public static bool npcChatRelease;
 
    public static bool editSign;
 
    public static bool editChest;
 
    public static bool blockInput = false;
 
    public static string blockKey = Microsoft.Xna.Framework.Input.Keys.None.ToString();
 
    public static string defaultChestName = string.Empty;
 
    public static string npcChatText = "";
 
    public static bool npcChatFocus1;
 
    public static bool npcChatFocus2;
 
    public static bool npcChatFocus3;
 
    public static bool npcChatFocus4;
 
    public static int oldNPCShop;
 
    public static int npcChatCornerItem;
 
    public Chest[] shop = new Chest[100];
 
    public static ItemShopSellbackHelper shopSellbackHelper = new ItemShopSellbackHelper();
 
    public static int[] travelShop = new int[40];
 
    public static List<string> anglerWhoFinishedToday = new List<string>();
 
    public static bool anglerQuestFinished;
 
    public static int anglerQuest;
 
    public static int[] anglerQuestItemNetIDs = new int[41]
    {
        2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459,
        2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469,
        2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479,
        2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 4393,
        4394
    };
 
    public static AmbienceServer AmbienceServer;
 
    public static ItemDropDatabase ItemDropsDB;
 
    public static BestiaryDatabase BestiaryDB;
 
    public static ItemDropResolver ItemDropSolver;
 
    public static BestiaryUnlocksTracker BestiaryTracker;
 
    public static UIBestiaryTest BestiaryUI;
 
    public static TeleportPylonsSystem PylonSystem;
 
    public static ShopHelper ShopHelper;
 
    public static GolfState LocalGolfState = new GolfState();
 
    public static DroneCameraTracker DroneCameraTracker = new DroneCameraTracker();
 
    public static WorkshopPublishingIndicator WorkshopPublishingIndicator = new WorkshopPublishingIndicator();
 
    public static IssueReportsIndicator IssueReporterIndicator = new IssueReportsIndicator();
 
    public static bool Support4K = true;
 
    public static float MinimumZoomComparerX = 1920f;
 
    public static float MinimumZoomComparerY = 1200f;
 
    private static int _renderTargetMaxSize = 2048;
 
    private static GraphicsProfile _selectedGraphicsProfile = ((!Program.IsXna) ? GraphicsProfile.HiDef : GraphicsProfile.Reach);
 
    private static GraphicsProfile _currentGraphicsProfile = _selectedGraphicsProfile;
 
    public static int LogicCheckScreenWidth = 1920;
 
    public static int LogicCheckScreenHeight = 1200;
 
    private static WorldPreparationState _worldPreparationState = WorldPreparationState.AwaitingData;
 
    public static float temporaryGUIScaleSlider = -1f;
 
    public static bool temporaryGUIScaleSliderUpdate = false;
 
    public static bool InGuideCraftMenu;
 
    public static bool InReforgeMenu;
 
    public static Item HoverItem = new Item();
 
    private static int backSpaceCount;
 
    private static float backSpaceRate;
 
    public static string motd = "";
 
    public static bool toggleFullscreen;
 
    public static int numDisplayModes;
 
    public static int[] displayWidth = new int[99];
 
    public static int[] displayHeight = new int[99];
 
    public static bool gameMenu = true;
 
    public static bool menuBGChangedDay = false;
 
    public static bool menuBGChangedNight = false;
 
    public static bool lockMenuBGChange = false;
 
    private static int maxLoadPlayer = 1000;
 
    private static int maxLoadWorld = 1000;
 
    public static List<PlayerFileData> PlayerList = new List<PlayerFileData>();
 
    public static PlayerFileData ActivePlayerFileData = new PlayerFileData();
 
    public static Player PendingPlayer = null;
 
    public static List<WorldFileData> WorldList = new List<WorldFileData>();
 
    public static WorldFileData ActiveWorldFileData = new WorldFileData();
 
    public static string WorldPath = Path.Combine(SavePath, "Worlds");
 
    public static string CloudWorldPath = "worlds";
 
    public static string PlayerPath = Path.Combine(SavePath, "Players");
 
    public static string CloudPlayerPath = "players";
 
    public static Preferences Configuration = new Preferences(SavePath + Path.DirectorySeparatorChar + "config.json");
 
    public static Preferences InputProfiles = new Preferences(SavePath + Path.DirectorySeparatorChar + "input profiles.json");
 
    public static KeyboardState inputText;
 
    public static KeyboardState oldInputText;
 
    public static int PendingResolutionWidth = 800;
 
    public static int PendingResolutionHeight = 600;
 
    public static bool PendingBorderlessState;
 
    public static int invasionType;
 
    public static double invasionX;
 
    public static int invasionSize;
 
    public static int invasionDelay;
 
    public static int invasionWarn;
 
    public static int invasionSizeStart;
 
    public static bool invasionProgressNearInvasion;
 
    public static int invasionProgressMode = 2;
 
    public static int invasionProgressIcon;
 
    public static int invasionProgress;
 
    public static int invasionProgressMax;
 
    public static int invasionProgressWave;
 
    public static int invasionProgressDisplayLeft;
 
    public static float invasionProgressAlpha;
 
    public static bool HasInteractibleObjectThatIsNotATile = false;
 
    public int currentNPCShowingChatBubble = -1;
 
    public static int[] npcFrameCount = new int[688]
    {
        1, 2, 2, 3, 6, 2, 2, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 2, 25, 23, 25,
        21, 15, 26, 2, 10, 1, 16, 16, 16, 3,
        1, 15, 3, 1, 3, 1, 1, 21, 25, 1,
        1, 1, 3, 3, 15, 3, 7, 7, 6, 5,
        6, 5, 3, 3, 23, 6, 3, 6, 6, 2,
        5, 6, 5, 7, 7, 4, 5, 8, 1, 5,
        1, 2, 4, 16, 5, 4, 4, 15, 16, 16,
        16, 2, 4, 6, 6, 18, 16, 1, 1, 1,
        1, 1, 1, 4, 3, 1, 1, 1, 1, 1,
        1, 5, 6, 7, 16, 1, 1, 25, 23, 12,
        20, 21, 1, 2, 2, 3, 6, 1, 1, 1,
        15, 4, 11, 1, 23, 6, 6, 6, 1, 2,
        2, 1, 3, 4, 1, 2, 1, 4, 2, 1,
        15, 3, 25, 4, 5, 7, 3, 2, 12, 12,
        4, 4, 4, 8, 8, 13, 5, 6, 4, 15,
        23, 3, 15, 8, 5, 4, 13, 15, 12, 4,
        14, 14, 3, 2, 5, 3, 2, 3, 23, 5,
        14, 16, 5, 2, 2, 12, 3, 3, 3, 3,
        2, 2, 2, 2, 2, 7, 14, 15, 16, 8,
        3, 15, 15, 16, 2, 3, 20, 25, 23, 26,
        4, 4, 16, 16, 20, 20, 20, 2, 2, 2,
        2, 8, 12, 3, 4, 2, 4, 25, 26, 26,
        6, 3, 3, 3, 3, 3, 5, 4, 4, 5,
        4, 6, 7, 15, 4, 7, 6, 1, 1, 2,
        4, 3, 5, 3, 3, 3, 4, 5, 6, 4,
        2, 1, 8, 4, 4, 1, 8, 1, 4, 15,
        15, 15, 15, 15, 15, 16, 15, 15, 15, 15,
        15, 3, 3, 3, 3, 3, 3, 16, 3, 6,
        12, 21, 21, 20, 16, 15, 15, 5, 5, 6,
        6, 5, 2, 7, 2, 6, 6, 6, 6, 6,
        15, 15, 15, 15, 15, 11, 4, 2, 2, 3,
        3, 3, 16, 15, 16, 10, 14, 12, 1, 10,
        8, 3, 3, 2, 2, 2, 2, 7, 15, 15,
        15, 6, 3, 10, 10, 6, 9, 8, 9, 8,
        20, 10, 6, 23, 1, 4, 24, 2, 4, 6,
        6, 13, 15, 15, 15, 15, 4, 4, 26, 23,
        8, 2, 4, 4, 4, 4, 2, 2, 4, 12,
        12, 9, 9, 9, 1, 9, 11, 2, 2, 9,
        5, 6, 4, 18, 8, 11, 1, 4, 5, 8,
        4, 1, 1, 1, 1, 4, 2, 5, 4, 11,
        5, 11, 1, 1, 1, 10, 10, 15, 8, 17,
        6, 6, 1, 12, 12, 13, 15, 9, 5, 10,
        7, 7, 7, 7, 7, 7, 7, 4, 4, 16,
        16, 25, 5, 7, 3, 13, 2, 6, 2, 19,
        19, 19, 20, 26, 3, 1, 1, 1, 1, 1,
        16, 21, 9, 16, 7, 6, 18, 13, 20, 12,
        12, 20, 6, 14, 14, 14, 14, 6, 1, 3,
        25, 19, 20, 22, 2, 4, 4, 4, 11, 9,
        8, 1, 9, 1, 8, 8, 12, 12, 11, 11,
        11, 11, 11, 11, 11, 11, 11, 1, 6, 9,
        1, 1, 1, 1, 1, 1, 4, 1, 10, 1,
        8, 4, 1, 5, 8, 8, 8, 8, 9, 9,
        5, 4, 8, 16, 8, 2, 3, 3, 6, 6,
        7, 13, 4, 4, 4, 4, 1, 1, 1, 8,
        25, 11, 14, 14, 14, 17, 17, 17, 5, 5,
        5, 14, 14, 14, 9, 9, 9, 9, 17, 17,
        16, 16, 18, 18, 10, 10, 10, 10, 4, 1,
        6, 9, 6, 4, 4, 4, 14, 4, 25, 13,
        3, 7, 6, 6, 1, 4, 4, 4, 4, 4,
        4, 4, 15, 15, 8, 8, 2, 6, 15, 15,
        6, 13, 5, 5, 7, 5, 14, 14, 4, 6,
        21, 1, 1, 1, 11, 12, 6, 6, 17, 6,
        16, 21, 16, 23, 5, 16, 2, 28, 28, 6,
        6, 6, 6, 6, 6, 6, 7, 7, 7, 7,
        7, 7, 7, 3, 4, 6, 27, 16, 2, 2,
        4, 3, 4, 23, 6, 1, 1, 2, 8, 8,
        14, 6, 6, 6, 6, 6, 2, 4, 14, 14,
        14, 14, 14, 14, 14, 1, 1, 13
    };
 
    public static Dictionary<int, byte> npcLifeBytes = new Dictionary<int, byte>();
 
    public static bool mouseExit;
 
    public static float exitScale = 0.8f;
 
    public static bool mouseReforge;
 
    public static float reforgeScale = 0.8f;
 
    public static Player clientPlayer = new Player();
 
    public static string getIP = defaultIP;
 
    public static string getPort = Convert.ToString(Netplay.ListenPort);
 
    public static bool menuMultiplayer;
 
    public static bool menuServer;
 
    public static int netMode;
 
    private static int _targetNetMode;
 
    private static bool _hasPendingNetmodeChange;
 
    public const int MaxTimeout = 120;
 
    public static int netPlayCounter;
 
    public static int lastNPCUpdate;
 
    public static int lastItemUpdate;
 
    public static int maxNPCUpdates = 5;
 
    public static int maxItemUpdates = 5;
 
    public static string cUp = "W";
 
    public static string cLeft = "A";
 
    public static string cDown = "S";
 
    public static string cRight = "D";
 
    public static string cJump = "Space";
 
    public static string cThrowItem = "T";
 
    public static string cHeal = "H";
 
    public static string cMana = "J";
 
    public static string cBuff = "B";
 
    public static string cHook = "E";
 
    public static string cTorch = "LeftShift";
 
    public static string cInv = "Escape";
 
    public static string cSmart = "LeftControl";
 
    public static string cMount = "R";
 
    public static string cFavoriteKey = "LeftAlt";
 
    public static bool cSmartCursorModeIsToggleAndNotHold = true;
 
    public static bool SmartCursorWanted_Mouse = false;
 
    public static bool SmartCursorWanted_GamePad = false;
 
    public static bool SmartCursorShowing = false;
 
    public static int SmartCursorX;
 
    public static int SmartCursorY;
 
    public static bool SmartInteractShowingGenuine;
 
    public static bool SmartInteractShowingFake;
 
    public static int SmartInteractX;
 
    public static int SmartInteractY;
 
    public static int SmartInteractNPC;
 
    public static int SmartInteractProj;
 
    public static bool SmartInteractPotionOfReturn;
 
    public static List<Microsoft.Xna.Framework.Point> SmartInteractTileCoords = new List<Microsoft.Xna.Framework.Point>();
 
    public static List<Microsoft.Xna.Framework.Point> SmartInteractTileCoordsSelected = new List<Microsoft.Xna.Framework.Point>();
 
    public static int TileInteractionLX = -1;
 
    public static int TileInteractionLY = -1;
 
    public static int TileInteractionHX = -1;
 
    public static int TileInteractionHY = -1;
 
    public static int cursorOverride = -1;
 
    public static int signHover = -1;
 
    public static string cMapZoomIn = "Add";
 
    public static string cMapZoomOut = "Subtract";
 
    public static string cMapAlphaUp = "PageUp";
 
    public static string cMapAlphaDown = "PageDown";
 
    public static string cMapFull = "M";
 
    public static string cMapStyle = "Tab";
 
    public static Microsoft.Xna.Framework.Input.Keys FavoriteKey = Microsoft.Xna.Framework.Input.Keys.LeftAlt;
 
    public static ColorSlidersSet mouseColorSlider = new ColorSlidersSet();
 
    public static ColorSlidersSet mouseBorderColorSlider = new ColorSlidersSet();
 
    public static Microsoft.Xna.Framework.Color mouseColor = new Microsoft.Xna.Framework.Color(255, 50, 95);
 
    public static Microsoft.Xna.Framework.Color cursorColor = Microsoft.Xna.Framework.Color.White;
 
    public static int cursorColorDirection = 1;
 
    public static float cursorAlpha;
 
    public static float cursorScale;
 
    public static bool signBubble;
 
    public static int signX = 0;
 
    public static int signY = 0;
 
    public static bool hideUI;
 
    public static bool releaseUI;
 
    public static FrameSkipMode FrameSkipMode = FrameSkipMode.Subtle;
 
    public static bool terrariasFixedTiming = true;
 
    private int splashCounter;
 
    public List<int> DrawCacheNPCsMoonMoon = new List<int>(200);
 
    public List<int> DrawCacheNPCsOverPlayers = new List<int>(200);
 
    public List<int> DrawCacheNPCProjectiles = new List<int>(200);
 
    public List<int> DrawCacheNPCsBehindNonSolidTiles = new List<int>(200);
 
    public List<int> DrawCacheProjsBehindNPCsAndTiles = new List<int>(1000);
 
    public List<int> DrawCacheProjsBehindNPCs = new List<int>(1000);
 
    public List<int> DrawCacheProjsBehindProjectiles = new List<int>(1000);
 
    public List<int> DrawCacheProjsOverWiresUI = new List<int>(1000);
 
    public List<int> DrawCacheProjsOverPlayers = new List<int>(1000);
 
    public List<int> DrawCacheFirstFractals = new List<int>(1000);
 
    public static ParticleRenderer ParticleSystem_World_OverPlayers = new ParticleRenderer();
 
    public static ParticleRenderer ParticleSystem_World_BehindPlayers = new ParticleRenderer();
 
    private static WindowStateController _windowMover;
 
    public static AnchoredEntitiesCollection sittingManager;
 
    public static AnchoredEntitiesCollection sleepingManager;
 
    public static MinimapFrameManager MinimapFrameManagerInstance;
 
    public static PlayerResourceSetsManager ResourceSetsManager;
 
    private static bool shouldSetDefaultUIScale = true;
 
    private static float newDefaultUIScale = 0f;
 
    public static bool IsInTheMiddleOfLoadingSettings;
 
    public static Microsoft.Xna.Framework.Point LastLoadedResolution;
 
    public static bool startFullscreen = false;
 
    public static string oldStatusText = "";
 
    public static string autoGenFileLocation = null;
 
    public static bool autoShutdown;
 
    private uint previousExecutionState;
 
    public static bool fastForwardTimeToDawn;
 
    public static int sundialCooldown;
 
    public static bool fastForwardTimeToDusk;
 
    public static int moondialCooldown;
 
    private static Stopwatch splashTimer = new Stopwatch();
 
    public static GeneralIssueReporter IssueReporter;
 
    private JArray _lastLoadedPacks;
 
    public static bool PreventUpdatingTargets = true;
 
    private IEnumerator _gameContentLoadProcess;
 
    public static bool _shouldUseWindyDayMusic = false;
 
    public static bool _shouldUseStormMusic = false;
 
    private int lastMusicPlayed = -1;
 
    private bool playOldTile;
 
    private static float _minWind = 0.34f;
 
    private static float _maxWind = 0.4f;
 
    private static float _minRain = 0.4f;
 
    private static float _maxRain = 0.5f;
 
    public static float ambientWaterfallX = -1f;
 
    public static float ambientWaterfallY = -1f;
 
    public static float ambientWaterfallStrength = 0f;
 
    public static float ambientLavafallX = -1f;
 
    public static float ambientLavafallY = -1f;
 
    public static float ambientLavafallStrength = 0f;
 
    public static float ambientLavaX = -1f;
 
    public static float ambientLavaY = -1f;
 
    public static float ambientLavaStrength;
 
    public static int ambientCounter;
 
    private static bool _isWaterfallMusicPlaying = false;
 
    private static bool _isLavafallMusicPlaying = false;
 
    public static IChatMonitor chatMonitor = new RemadeChatMonitor();
 
    public static int ProjectileUpdateLoopIndex = -1;
 
    public static GameTipsDisplay gameTips;
 
    private Stopwatch _worldUpdateTimeTester = new Stopwatch();
 
    public SpelunkerProjectileHelper SpelunkerProjectileHelper = new SpelunkerProjectileHelper();
 
    public ChumBucketProjectileHelper ChumBucketProjectileHelper = new ChumBucketProjectileHelper();
 
    public static int weatherVaneBobframe = 0;
 
    private float logoRotation;
 
    private float logoRotationDirection = -1f;
 
    private float logoRotationSpeed = 1f;
 
    private float logoScale = 1f;
 
    private float logoScaleDirection = 1f;
 
    private float logoScaleSpeed = 1f;
 
    private static int maxMenuItems = 16;
 
    private float[] menuItemScale = new float[maxMenuItems];
 
    private int focusMenu = -1;
 
    private int selectedMenu = -1;
 
    private int selectedMenu2 = -1;
 
    public static int selectedPlayer = 0;
 
    public static int selectedWorld;
 
    public static int menuMode;
 
    public static int menuSkip;
 
    private static bool _needsLanguageSelect = true;
 
    private static Item tooltipPrefixComparisonItem = new Item();
 
    private MouseTextCache _mouseTextCache;
 
    public int textBlinkerCount;
 
    public int textBlinkerState;
 
    public static string newWorldName = "";
 
    private static Vector3 shimmerShine = new Vector3(1f, 0.5f, 1f);
 
    private static int[] specX = new int[1000];
 
    private static int[] specY = new int[1000];
 
    public TilePaintSystemV2 TilePaintSystem;
 
    public TileDrawing TilesRenderer;
 
    public WallDrawing WallsRenderer;
 
    private AmbientWindSystem _ambientWindSys = new AmbientWindSystem();
 
    private List<Player> _playersThatDrawBehindNPCs = new List<Player>(255);
 
    private List<Player> _playersThatDrawAfterProjectiles = new List<Player>(255);
 
    private List<DrawData> _voidLensData = new List<DrawData>();
 
    private List<DrawData> _voidLensDataSillouette = new List<DrawData>();
 
    private List<DrawData> _voidLensDataSillouette2 = new List<DrawData>();
 
    private static BlendState _multiplyBlendState = null;
 
    private static StardewValleyAnimation _stardewAnimation;
 
    private static UnifiedRandom _tempSeededRandom = new UnifiedRandom();
 
    private TextDisplayCache _textDisplayCache = new TextDisplayCache();
 
    private List<int> _occupantsListToDrawNPCHouses = new List<int>();
 
    private List<int> _npcsWithBannersToDraw = new List<int>();
 
    private bool _imeToggle;
 
    private static int _lastHoveredLoadoutIndex = -1;
 
    private List<int> _npcTypesThatAlreadyDrewAHead = new List<int>();
 
    private int[] _npcIndexWhoHoldsHeadIndex = new int[NPCHeadID.Count];
 
    private static List<string> _requiredObjecsForCraftingText = new List<string>();
 
    private static bool _preventCraftingBecauseClickWasUsedToChangeFocusedRecipe;
 
    private static int _currentRecipeBeingCrafted = -1;
 
    private static bool hidePVPIcons = false;
 
    public static bool HoveringOverAnNPC;
 
    public static string hoverItemName = "";
 
    public static Microsoft.Xna.Framework.Color inventoryBack = new Microsoft.Xna.Framework.Color(220, 220, 220, 220);
 
    public static bool mouseText;
 
    private static int mH;
 
    private static int rare;
 
    public static int hairStart;
 
    private static int oldHairStyle;
 
    private static Microsoft.Xna.Framework.Color oldHairColor;
 
    public static int selClothes;
 
    private static Microsoft.Xna.Framework.Color[] oldClothesColor = new Microsoft.Xna.Framework.Color[6];
 
    private static int oldClothesStyle;
 
    public static int interactedDresserTopLeftX;
 
    public static int interactedDresserTopLeftY;
 
    public static Player dresserInterfaceDummy;
 
    private bool _needToSetupDrawInterfaceLayers = true;
 
    private List<GameInterfaceLayer> _gameInterfaceLayers;
 
    private static GameTime _drawInterfaceGameTime;
 
    private byte instrumentMouseFixHack;
 
    private static bool _settingsButtonIsPushedToSide;
 
    private static bool _MouseOversCanClear;
 
    private static Vector2 _itemIconCacheScreenPosition;
 
    private static int _itemIconCacheSelectedItemID;
 
    private static int _itemIconCacheTime;
 
    private static bool _cannotDrawAccessoriesHorizontally = false;
 
    public static Microsoft.Xna.Framework.Color selColor = Microsoft.Xna.Framework.Color.White;
 
    public static int focusColor;
 
    public static int colorDelay;
 
    public static int setKey = -1;
 
    public static int bgScroll;
 
    public static bool autoPass;
 
    public static int menuFocus = 0;
 
    public static float hBar = -1f;
 
    public static float sBar = -1f;
 
    public static float lBar = 1f;
 
    public static float aBar = 1f;
 
    private int grabColorSlider;
 
    public static bool blockMouse;
 
    private static bool _blockFancyUIWhileLoading;
 
    private bool[] menuWide = new bool[100];
 
    public static float GamepadCursorAlpha = 0f;
 
    private bool _needsMenuUIRecalculation;
 
    public static float MenuXMovement = 0f;
 
    public RejectionMenuInfo RejectionMenuInfo;
 
    private float _splashFrameCount;
 
    private bool quickSplash;
 
    private float hellBlackBoxBottom;
 
    public static float InitialMapScale = 1f;
 
    public static float MapScale = 1f;
 
    private static int _minimapTopRightAnchorOffsetTowardsLeft = 52;
 
    private static int _minimapTopRightAnchorOffsetTowardsBottom = 90;
 
    public static bool cancelWormHole = false;
 
    private static VertexColors _glowPaintColors = new VertexColors(Microsoft.Xna.Framework.Color.White);
 
    protected List<Tuple<int, int, ushort>> DrawWiresSpecialTiles = new List<Tuple<int, int, ushort>>();
 
    public static float lightning;
 
    private static float lightningDecay = 1f;
 
    private static float lightningSpeed = 0f;
 
    private static int thunderDelay;
 
    public static int thunderDistance;
 
    private static string[] MonolithFilterNames = new string[5] { "MonolithVortex", "MonolithNebula", "MonolithStardust", "MonolithSolar", "MonolithMoonLord" };
 
    private static string[] MonolithSkyNames = new string[5] { "MonolithVortex", "MonolithNebula", "MonolithStardust", "MonolithSolar", "MonolithMoonLord" };
 
    private static float backgroundLayerTransitionSpeed = 0.05f;
 
    public static float atmo;
 
    private static float bgScale = 1f;
 
    private static int bgWidthScaled = (int)(1024f * bgScale);
 
    public static Microsoft.Xna.Framework.Color ColorOfTheSkies;
 
    private static Microsoft.Xna.Framework.Color ColorOfSurfaceBackgroundsBase = Microsoft.Xna.Framework.Color.White;
 
    private static Microsoft.Xna.Framework.Color ColorOfSurfaceBackgroundsModified = Microsoft.Xna.Framework.Color.White;
 
    private float screenOff;
 
    private float scAdj;
 
    private float cTop;
 
    private bool _isDrawingOrUpdating;
 
    public static List<INeedRenderTargetContent> ContentThatNeedsRenderTargets = new List<INeedRenderTargetContent>();
 
    private static bool _cameraPanHasBlackTransition = false;
 
    public CameraModifierStack CameraModifiers = new CameraModifierStack();
 
    public static bool starGame = false;
 
    public static int starsHit = 0;
 
    private static string _oldNetplayStatusText;
 
    private static TextSnippet[] _netplayStatusTextSnippets;
 
    public static int ladyBugRainBoost = 0;
 
    private static bool _canShowMeteorFall;
 
    private static bool _isResizingAndRemakingTargets = false;
 
    public static bool CanUpdateGameplay { get; private set; }
 
    public static Vector2 ViewPosition => screenPosition + GameViewMatrix.Translation;
 
    public static Vector2 ViewSize => new Vector2(screenWidth, screenHeight) / GameViewMatrix.Zoom;
 
    public static Matrix CurrentWantedZoomMatrix => _currentWantedZoomMatrix;
 
    public static Matrix UIScaleMatrix => _uiScaleMatrix;
 
    public static float UIScaleWanted => _uiScaleWanted;
 
    public static float UIScale
    {
        get
        {
            return _uiScaleUsed;
        }
        set
        {
            _uiScaleWanted = value;
            float uIScaleMax = instance.UIScaleMax;
            if (value > uIScaleMax)
            {
                value = uIScaleMax;
            }
            _uiScaleUsed = value;
            _uiScaleMatrix = Matrix.CreateScale(value, value, 1f);
        }
    }
 
    public float UIScaleMax
    {
        get
        {
            int realScreenWidth = PlayerInput.RealScreenWidth;
            float val2 = Math.Min(val2: (float)PlayerInput.RealScreenHeight / 600f, val1: (float)realScreenWidth / 800f);
            return Math.Max(1f, val2);
        }
    }
 
    public static bool RenderTargetsRequired
    {
        get
        {
            if (!(GameZoomTarget > 1f))
            {
                return GameViewMatrix.TransformationMatrix.M11 > 1f;
            }
            return true;
        }
    }
 
    public static bool IsItRaining => cloudAlpha > 0f;
 
    public static bool ThickMouse => MouseBorderColor != Microsoft.Xna.Framework.Color.Transparent;
 
    public static bool GamepadDisableCursorItemIcon
    {
        get
        {
            if (PlayerInput.UsingGamepad)
            {
                return GamepadDisableCursorItemIconInner;
            }
            return false;
        }
    }
 
    public static string SavePath => Program.SavePath;
 
    public static GameModeData GameModeInfo => _currentGameModeInfo;
 
    public static int GameMode
    {
        get
        {
            if (ActiveWorldFileData == null)
            {
                return 0;
            }
            return ActiveWorldFileData.GameMode;
        }
        set
        {
            if (ActiveWorldFileData != null && RegisteredGameModes.TryGetValue(value, out var value2))
            {
                ActiveWorldFileData.GameMode = value;
                _currentGameModeInfo = value2;
            }
        }
    }
 
    public static bool specialSeedWorld
    {
        get
        {
            if (!drunkWorld && !getGoodWorld && !tenthAnniversaryWorld && !notTheBeesWorld && !dontStarveWorld && !remixWorld && !noTrapsWorld)
            {
                return zenithWorld;
            }
            return true;
        }
    }
 
    public static bool masterMode
    {
        get
        {
            if (ActiveWorldFileData == null)
            {
                return false;
            }
            if (_overrideForMasterMode.HasValue)
            {
                return _overrideForMasterMode.Value;
            }
            if (getGoodWorld && _currentGameModeInfo.IsExpertMode)
            {
                return true;
            }
            return _currentGameModeInfo.IsMasterMode;
        }
    }
 
    public static bool expertMode
    {
        get
        {
            if (ActiveWorldFileData == null)
            {
                return false;
            }
            if (_overrideForExpertMode.HasValue)
            {
                return _overrideForExpertMode.Value;
            }
            if (getGoodWorld)
            {
                return true;
            }
            return _currentGameModeInfo.IsExpertMode;
        }
    }
 
    public static AchievementManager Achievements => instance._achievements;
 
    public static AchievementAdvisor AchievementAdvisor => instance._achievementAdvisor;
 
    public static ulong UnpausedUpdateSeed { get; private set; }
 
    public static Effect screenShader => ScreenShaderRef.Value;
 
    public static Effect pixelShader => PixelShaderRef.Value;
 
    public static Effect vertexPixelShader => VertexPixelShaderRef.Value;
 
    public static Effect tileShader => TileShaderRef.Value;
 
    [Old("Transform is deprecated. Please use GameViewMatrix & GUIViewMatrix")]
    public static Matrix Transform => GameViewMatrix.TransformationMatrix;
 
    public static Vector2 MouseScreen => new Vector2(mouseX, mouseY);
 
    public static Vector2 MouseWorld
    {
        get
        {
            Vector2 result = MouseScreen + screenPosition;
            if (player[myPlayer].gravDir == -1f)
            {
                result.Y = screenPosition.Y + (float)screenHeight - (float)mouseY;
            }
            return result;
        }
    }
 
    public static INetDiagnosticsUI ActiveNetDiagnosticsUI
    {
        get
        {
            if (_activeNetDiagnosticsUI == null)
            {
                INetDiagnosticsUI activeNetDiagnosticsUI;
                if (!dedServ)
                {
                    INetDiagnosticsUI netDiagnosticsUI = new NetDiagnosticsUI();
                    activeNetDiagnosticsUI = netDiagnosticsUI;
                }
                else
                {
                    INetDiagnosticsUI netDiagnosticsUI = new EmptyDiagnosticsUI();
                    activeNetDiagnosticsUI = netDiagnosticsUI;
                }
                _activeNetDiagnosticsUI = activeNetDiagnosticsUI;
            }
            return _activeNetDiagnosticsUI;
        }
    }
 
    public static uint GameUpdateCount => _gameUpdateCount;
 
    public static SamplerState DefaultSamplerState
    {
        get
        {
            if (!drawToScreen)
            {
                return SamplerState.PointClamp;
            }
            return SamplerState.LinearClamp;
        }
    }
 
    public static int UnderworldLayer => maxTilesY - 200;
 
    public static float WindForVisuals => windSpeedCurrent;
 
    public static Player LocalPlayer => player[myPlayer];
 
    public static CreativeUnlocksTracker LocalPlayerCreativeTracker => player[myPlayer].creativeTracker;
 
    public static int npcShop { get; private set; }
 
    public static string playerPathName => ActivePlayerFileData.Path;
 
    public static string worldPathName => ActiveWorldFileData.Path;
 
    public static bool SmartCursorWanted
    {
        get
        {
            if (PlayerInput.SteamDeckIsUsed && PlayerInput.SettingsForUI.CurrentCursorMode == CursorMode.Mouse)
            {
                return SmartCursorWanted_Mouse;
            }
            if (PlayerInput.UsingGamepad)
            {
                return SmartCursorWanted_GamePad;
            }
            return SmartCursorWanted_Mouse;
        }
    }
 
    public static bool SmartCursorIsUsed => SmartCursorWanted;
 
    public static bool HasSmartInteractTarget
    {
        get
        {
            if (SmartInteractNPC == -1 && (SmartInteractX == -1 || SmartInteractY == -1))
            {
                return SmartInteractProj != -1;
            }
            return true;
        }
    }
 
    public static bool IsItAHappyWindyDay => _shouldUseWindyDayMusic;
 
    public static bool IsItStorming => _shouldUseStormMusic;
 
    public static bool WindyEnoughForKiteDrops => Math.Abs(windSpeedTarget) >= _maxWind;
 
    public static bool ShouldPVPDraw => netMode == 1;
 
    public int RecommendedEquipmentAreaPushUp
    {
        get
        {
            if (player[myPlayer].CanDemonHeartAccessoryBeShown())
            {
                return 610 + PlayerInput.SettingsForUI.PushEquipmentAreaUp.ToInt() * 30;
            }
            return 600;
        }
    }
 
    public static bool ShouldDrawInfoIconsHorizontally
    {
        get
        {
            if (_cannotDrawAccessoriesHorizontally)
            {
                return false;
            }
            if (mapStyle == 1 && mapEnabled && screenHeight < 820)
            {
                return false;
            }
            if (mapStyle != 1 && screenWidth < 855)
            {
                return false;
            }
            if (PlayerInput.UsingGamepad)
            {
                return false;
            }
            return true;
        }
    }
 
    public static bool CanShowInfoAccs
    {
        get
        {
            if (npcChatText == null || npcChatText == "" || player[myPlayer].chest > -1)
            {
                return player[myPlayer].sign < 0;
            }
            return false;
        }
    }
 
    public static Microsoft.Xna.Framework.Point ScreenSize => new Microsoft.Xna.Framework.Point(screenWidth, screenHeight);
 
    public static bool IsGraphicsDeviceAvailable
    {
        get
        {
            if (!instance.GraphicsDevice.IsDisposed)
            {
                return instance.GraphicsDevice.GraphicsDeviceStatus == GraphicsDeviceStatus.Normal;
            }
            return false;
        }
    }
 
    public static event Action OnEnginePreload;
 
    public static event Action<Vector2> OnResolutionChanged;
 
    public static event Action OnEngineLoad;
 
    public static event Action OnTickForThirdPartySoftwareOnly;
 
    public static event Action OnTickForInternalCodeOnly;
 
    public static event Action<GameTime> OnPreDraw;
 
    public static event Action<GameTime> OnPostDraw;
 
    public static event Action<Vector2, float> OnPostFullscreenMapDraw;
 
    public static event Action OnRenderTargetsReleased;
 
    public static event ResolutionChangeEvent OnRenderTargetsInitialized;
 
    public static void ToggleGameplayUpdates(bool state)
    {
        CanUpdateGameplay = state;
    }
 
    public static void SetRecommendedZoomContext(Matrix matrix)
    {
        _currentWantedZoomMatrix = matrix;
    }
 
    public static void FindAnnouncementBoxStatus()
    {
        AnnouncementBoxDisabled = Program.LaunchParameters.ContainsKey("-disableannouncementbox");
        if (Program.LaunchParameters.TryGetValue("-announcementboxrange", out var value) && int.TryParse(value, out var result))
        {
            AnnouncementBoxRange = result;
        }
    }
 
    public static bool CanPlayCreditsRoll()
    {
        if (!gameMenu && LocalPlayer.hasCreditsSceneMusicBox)
        {
            return true;
        }
        if (gameMenu && menuMode == 3000)
        {
            return true;
        }
        return CreditsRollEvent.IsEventOngoing;
    }
 
    public static void SetCameraLerp(float lerp, int time)
    {
        cameraLerp = lerp;
        cameraLerpTimer = 0;
        cameraLerpTimeToggle = time;
        cameraGamePadLerp = false;
    }
 
    public static void SetCameraGamepadLerp(float lerp)
    {
        _ = cameraLerp;
        _ = 0f;
    }
 
    public static Vector2 ReverseGravitySupport(Vector2 pos, float height = 0f)
    {
        if (player[myPlayer].gravDir != -1f)
        {
            return pos;
        }
        pos.Y = (float)screenHeight - pos.Y - height;
        return pos;
    }
 
    public static Microsoft.Xna.Framework.Point ReverseGravitySupport(Microsoft.Xna.Framework.Point pos, int height = 0)
    {
        if (player[myPlayer].gravDir != -1f)
        {
            return pos;
        }
        pos.Y = screenHeight - pos.Y - height;
        return pos;
    }
 
    public static Microsoft.Xna.Framework.Rectangle ReverseGravitySupport(Microsoft.Xna.Framework.Rectangle box)
    {
        if (player[myPlayer].gravDir != -1f)
        {
            return box;
        }
        box.Y = screenHeight - box.Y - box.Height;
        return box;
    }
 
    public void SetMouseNPC(int index, int type)
    {
        mouseNPCIndex = index;
        mouseNPCType = type;
    }
 
    public void SetMouseNPC_ToHousingQuery()
    {
        SetMouseNPC(-1, 0);
    }
 
    [DllImport("User32")]
    private static extern int RemoveMenu(IntPtr hMenu, int nPosition, int wFlags);
 
    [DllImport("User32")]
    private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
 
    [DllImport("User32")]
    private static extern int GetMenuItemCount(IntPtr hWnd);
 
    [DllImport("kernel32.dll")]
    public static extern IntPtr LoadLibrary(string dllToLoad);
 
    public static MoonPhase GetMoonPhase()
    {
        return (MoonPhase)moonPhase;
    }
 
    public static Vector2 DrawPlayerItemPos(float gravdir, int itemtype)
    {
        float num = 10f;
        GetItemDrawFrame(itemtype, out var _, out var r);
        Vector2 result = r.Size() / 2f;
        switch (itemtype)
        {
        case 95:
            num = 6f;
            result.Y += 2f * gravdir;
            break;
        case 1295:
            num = 4f;
            break;
        case 3611:
            num = 2f;
            break;
        case 3350:
            num = 2f;
            break;
        case 2624:
            num = 4f;
            break;
        case 3018:
            num = 2f;
            break;
        case 3007:
            num = 4f;
            result.Y -= 1f * gravdir;
            break;
        case 3107:
            num = 4f;
            result.Y += 2f * gravdir;
            break;
        case 3008:
            num = -7f;
            result.Y += 2f * gravdir;
            break;
        case 1255:
            num = 6f;
            result.Y += 0f * gravdir;
            break;
        case 2269:
            num = 2f;
            result.Y += 2f * gravdir;
            break;
        case 1265:
            num = -8f;
            result.Y += 4f * gravdir;
            break;
        case 2272:
            num = 0f;
            result.Y += 4f * gravdir;
            break;
        case 3029:
            num = 4f;
            break;
        case 4381:
            num = 4f;
            break;
        case 2796:
            num = -28f;
            result.Y += 2f * gravdir;
            break;
        case 2797:
            num = 0f;
            break;
        case 2610:
            num = 0f;
            break;
        case 2623:
            num = -30f;
            result.Y -= 4f * gravdir;
            break;
        case 3546:
            num = -14f;
            result.Y -= 6f * gravdir;
            break;
        case 1835:
            num = -2f;
            result.Y += 2f * gravdir;
            break;
        default:
            switch (itemtype)
            {
            case 2624:
                num = -4f;
                break;
            case 3859:
                num = -2f;
                break;
            case 2888:
                num = 6f;
                break;
            case 2223:
                num = 2f;
                result.Y -= 2f * gravdir;
                break;
            case 1782:
                num = 0f;
                result.Y += 4f * gravdir;
                break;
            case 1929:
                num = 0f;
                result.Y += 2f * gravdir;
                break;
            case 2270:
                num = -4f;
                break;
            case 1784:
                num = 0f;
                result.Y += 4f * gravdir;
                break;
            case 1000:
                num = 6f;
                result.Y += 0f * gravdir;
                break;
            case 1178:
                num = 4f;
                result.Y += 0f * gravdir;
                break;
            case 1319:
                num = 0f;
                result.Y += 0f * gravdir;
                break;
            case 1297:
                num = -8f;
                result.Y += 0f * gravdir;
                break;
            case 1121:
                num = 6f;
                result.Y -= 2f * gravdir;
                break;
            case 1314:
                num = 2f;
                break;
            case 1258:
                num = 2f;
                result.Y -= 2f * gravdir;
                break;
            case 1155:
                num = -10f;
                result.Y -= 2f * gravdir;
                break;
            case 1156:
                num = -2f;
                break;
            case 4703:
                num = -3f;
                result.Y -= 2f * gravdir;
                break;
            case 5117:
                num = -1f;
                break;
            case 96:
                num = -8f;
                result.Y += 2f * gravdir;
                break;
            case 1870:
                num = -8f;
                result.Y += 2f * gravdir;
                break;
            case 1260:
                num = -8f;
                result.Y += 2f * gravdir;
                break;
            case 1254:
                num = -6f;
                result.Y += 2f * gravdir;
                break;
            case 98:
                num = -5f;
                result.Y -= 2f * gravdir;
                break;
            case 534:
                num = -2f;
                result.Y += 1f * gravdir;
                break;
            case 679:
                num = 0f;
                result.Y += 2f * gravdir;
                break;
            case 964:
                num = 0f;
                result.Y += 0f * gravdir;
                break;
            case 533:
                num = -7f;
                result.Y -= 2f * gravdir;
                break;
            case 1553:
                num = -10f;
                result.Y -= 2f * gravdir;
                break;
            case 506:
                num = 0f;
                result.Y -= 2f * gravdir;
                break;
            case 1910:
                num = 0f;
                result.Y -= 2f * gravdir;
                break;
            case 494:
            case 508:
                num = -2f;
                break;
            case 434:
                num = 0f;
                result.Y -= 2f * gravdir;
                break;
            case 514:
                num = 0f;
                result.Y += 3f * gravdir;
                break;
            case 435:
            case 436:
            case 481:
            case 578:
            case 1187:
            case 1194:
            case 1201:
            case 1229:
                num = -2f;
                result.Y -= 2f * gravdir;
                break;
            case 197:
                num = -5f;
                result.Y += 4f * gravdir;
                break;
            case 4060:
                num = -2f;
                result.Y += 4f * gravdir;
                break;
            case 126:
                num = 4f;
                result.Y += 4f * gravdir;
                break;
            case 800:
                num = 4f;
                result.Y += 2f * gravdir;
                break;
            case 127:
                num = 4f;
                result.Y += 2f * gravdir;
                break;
            case 157:
                num = 6f;
                result.Y += 2f * gravdir;
                break;
            case 160:
                num = -8f;
                break;
            case 164:
            case 219:
                num = 0f;
                result.Y += 2f * gravdir;
                break;
            case 165:
            case 272:
                num = 4f;
                result.Y += 4f * gravdir;
                break;
            case 3870:
                num = 4f;
                result.Y += 4f * gravdir;
                break;
            case 266:
                num = 0f;
                result.Y += 2f * gravdir;
                break;
            case 281:
                num = 6f;
                result.Y -= 6f * gravdir;
                break;
            case 986:
                num = 6f;
                result.Y -= 10f * gravdir;
                break;
            case 682:
                num = 4f;
                break;
            case 4953:
                num = -4f;
                break;
            case 758:
                num -= 20f;
                result.Y += 0f * gravdir;
                break;
            case 759:
                num -= 18f;
                result.Y += 2f * gravdir;
                break;
            case 760:
                num -= 12f;
                result.Y += 2f * gravdir;
                break;
            case 1946:
                num -= 12f;
                result.Y += 2f * gravdir;
                break;
            case 779:
                num = 0f;
                result.Y += 2f * gravdir;
                break;
            case 5134:
                num = 0f;
                result.Y += 2f * gravdir;
                break;
            case 905:
                num = -5f;
                result.Y += 0f * gravdir;
                break;
            case 930:
                num = 4f;
                result.Y += 2f * gravdir;
                break;
            case 3788:
                num = 2f;
                result.Y += 2f * gravdir;
                break;
            }
            break;
        }
        result.X = num;
        return result;
    }
 
    public static void SetupTileMerge()
    {
        int count = TileID.Count;
        tileMerge = new bool[count][];
        for (int i = 0; i < tileMerge.Length; i++)
        {
            tileMerge[i] = new bool[count];
        }
        for (int j = 0; j < TileID.Count; j++)
        {
            bool flag = j == 10 || j == 387 || j == 541;
            TileID.Sets.BlockMergesWithMergeAllBlock[j] = !flag && tileSolid[j] && !tileSolidTop[j];
        }
    }
 
    public static void RegisterItemAnimation(int index, DrawAnimation animation)
    {
        if (!itemAnimationsRegistered.Contains(index))
        {
            itemAnimationsRegistered.Add(index);
        }
        itemAnimations[index] = animation;
    }
 
    public static void InitializeItemAnimations()
    {
        for (int i = 0; i < itemAnimations.Length; i++)
        {
            itemAnimations[i] = null;
        }
        itemAnimationsRegistered.Clear();
        RegisterItemAnimation(3581, new DrawAnimationVertical(4, 4));
        RegisterItemAnimation(3580, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(75, new DrawAnimationVertical(5, 8)
        {
            PingPong = true
        });
        RegisterItemAnimation(575, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(547, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(520, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(548, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(521, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(549, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(3453, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(3454, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(3455, new DrawAnimationVertical(6, 4));
        RegisterItemAnimation(4068, new DrawAnimationVertical(6, 4)
        {
            NotActuallyAnimating = true
        });
        RegisterItemAnimation(4069, new DrawAnimationVertical(6, 4)
        {
            NotActuallyAnimating = true
        });
        RegisterItemAnimation(4070, new DrawAnimationVertical(6, 4)
        {
            NotActuallyAnimating = true
        });
        for (int j = 0; j < ItemID.Sets.IsFood.Length; j++)
        {
            if (ItemID.Sets.IsFood[j])
            {
                RegisterItemAnimation(j, new DrawAnimationVertical(int.MaxValue, 3));
            }
        }
    }
 
    public static void SetGraphicsProfile(GraphicsProfile profile, bool forceSet)
    {
        if (_currentGraphicsProfile != profile || forceSet)
        {
            _selectedGraphicsProfile = profile;
            SetGraphicsProfileInternal();
        }
    }
 
    private static void SetGraphicsProfileInternal()
    {
        _currentGraphicsProfile = _selectedGraphicsProfile;
        graphics.GraphicsProfile = _selectedGraphicsProfile;
        switch (_selectedGraphicsProfile)
        {
        case GraphicsProfile.HiDef:
            maxScreenW = 4096;
            maxScreenH = 4096;
            _renderTargetMaxSize = 4096;
            TrySupporting8K();
            break;
        case GraphicsProfile.Reach:
            maxScreenW = 1920;
            maxScreenH = 1200;
            _renderTargetMaxSize = 2048;
            break;
        }
        try
        {
            graphics.ApplyChanges();
        }
        catch (NoSuitableGraphicsDeviceException)
        {
            if (_currentGraphicsProfile == GraphicsProfile.HiDef)
            {
                _selectedGraphicsProfile = GraphicsProfile.Reach;
                SetGraphicsProfileInternal();
            }
        }
        instance.EnsureRenderTargetContent();
    }
 
    private static void TrySupporting8K()
    {
        if (!Platform.IsWindows)
        {
            return;
        }
        instance.ReleaseTargets();
        Type type = Assembly.GetAssembly(typeof(GraphicsProfile)).GetType("Microsoft.Xna.Framework.Graphics.ProfileCapabilities", throwOnError: true);
        if (type != null)
        {
            FieldInfo field = type.GetField("MaxTextureSize", BindingFlags.Instance | BindingFlags.NonPublic);
            FieldInfo field2 = type.GetField("HiDef", BindingFlags.Static | BindingFlags.NonPublic);
            if (field != null && field2 != null)
            {
                field.SetValue(field2.GetValue(null), 8192);
            }
        }
    }
 
    public static void AnglerQuestSwap()
    {
        if (netMode == 1)
        {
            return;
        }
        anglerWhoFinishedToday.Clear();
        anglerQuestFinished = false;
        bool flag = NPC.downedBoss1 || NPC.downedBoss2 || NPC.downedBoss3 || hardMode || NPC.downedSlimeKing || NPC.downedQueenBee;
        bool flag2 = true;
        while (flag2)
        {
            flag2 = false;
            anglerQuest = rand.Next(anglerQuestItemNetIDs.Length);
            int num = anglerQuestItemNetIDs[anglerQuest];
            if (num == 2454 && (!hardMode || WorldGen.crimson))
            {
                flag2 = true;
            }
            if (num == 2457 && WorldGen.crimson)
            {
                flag2 = true;
            }
            if (num == 2462 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2463 && (!hardMode || !WorldGen.crimson))
            {
                flag2 = true;
            }
            if (num == 2465 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2468 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2471 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2473 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2477 && !WorldGen.crimson)
            {
                flag2 = true;
            }
            if (num == 2480 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2483 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2484 && !hardMode)
            {
                flag2 = true;
            }
            if (num == 2485 && WorldGen.crimson)
            {
                flag2 = true;
            }
            if ((num == 2476 || num == 2453 || num == 2473) && !flag)
            {
                flag2 = true;
            }
        }
        NetMessage.SendAnglerQuest(-1);
    }
 
    public void UpdateParticleSystems()
    {
        ParticleSystem_World_OverPlayers.Update();
        ParticleSystem_World_BehindPlayers.Update();
    }
 
    public static void TrySetPreparationState(WorldPreparationState state)
    {
        if (state == WorldPreparationState.ProcessingData)
        {
            _worldPreparationState = state;
        }
    }
 
    public static void UpdateWorldPreparationState()
    {
        if (netMode != 1)
        {
            _worldPreparationState = WorldPreparationState.Ready;
            return;
        }
        if (netMode == 1 && gameMenu && _worldPreparationState == WorldPreparationState.Ready)
        {
            _worldPreparationState = WorldPreparationState.AwaitingData;
        }
        if (netMode == 1 && _worldPreparationState == WorldPreparationState.ProcessingData)
        {
            _worldPreparationState = WorldPreparationState.Ready;
            gameMenu = false;
            FixUIScale();
            ChatHelper.ShowCachedMessages();
            ChatHelper.ClearDelayedMessagesCache();
        }
    }
 
    public static bool InSmartCursorHighlightArea(int x, int y, out bool actuallySelected)
    {
        actuallySelected = SmartInteractTileCoordsSelected.Contains(new Microsoft.Xna.Framework.Point(x, y));
        if (hideUI)
        {
            return false;
        }
        if (Collision.InTileBounds(x, y, TileInteractionLX, TileInteractionLY, TileInteractionHX, TileInteractionHY))
        {
            return SmartInteractTileCoords.Contains(new Microsoft.Xna.Framework.Point(x, y));
        }
        return false;
    }
 
    public static void LoadWorlds()
    {
        WorldList.Clear();
        if (!Utils.TryCreatingDirectory(WorldPath))
        {
            return;
        }
        string[] files = Directory.GetFiles(WorldPath, "*.wld");
        int num = Math.Min(files.Length, maxLoadWorld);
        if (dedServ)
        {
            for (int i = 0; i < num; i++)
            {
                WorldFileData allMetadata = WorldFile.GetAllMetadata(files[i], cloudSave: false);
                if (allMetadata != null)
                {
                    WorldList.Add(allMetadata);
                }
                else
                {
                    WorldList.Add(WorldFileData.FromInvalidWorld(files[i], cloudSave: false));
                }
            }
        }
        else
        {
            for (int j = 0; j < num; j++)
            {
                WorldFileData allMetadata2 = WorldFile.GetAllMetadata(files[j], cloudSave: false);
                if (allMetadata2 != null)
                {
                    WorldList.Add(allMetadata2);
                }
                else
                {
                    WorldList.Add(WorldFileData.FromInvalidWorld(files[j], cloudSave: false));
                }
            }
        }
        if (SocialAPI.Cloud != null)
        {
            foreach (string item in from path in SocialAPI.Cloud.GetFiles()
                where path.StartsWith(CloudWorldPath, StringComparison.CurrentCultureIgnoreCase) && path.EndsWith(".wld", StringComparison.CurrentCultureIgnoreCase)
                select path)
            {
                WorldFileData allMetadata3 = WorldFile.GetAllMetadata(item, cloudSave: true);
                if (allMetadata3 != null)
                {
                    WorldList.Add(allMetadata3);
                }
                else
                {
                    WorldList.Add(WorldFileData.FromInvalidWorld(item, cloudSave: true));
                }
            }
        }
        WorldList.Sort(WorldListSortMethod);
    }
 
    private static int WorldListSortMethod(WorldFileData data1, WorldFileData data2)
    {
        if (data1 == null && data2 == null)
        {
            return 0;
        }
        if (data1 == null || data1.Name == null)
        {
            return 1;
        }
        if (data2 == null || data2.Name == null)
        {
            return -1;
        }
        return data1.Name.CompareTo(data2.Name);
    }
 
    public static void LoadPlayers()
    {
        PlayerList.Clear();
        if (!Utils.TryCreatingDirectory(PlayerPath))
        {
            return;
        }
        string[] files = Directory.GetFiles(PlayerPath, "*.plr");
        int num = Math.Min(maxLoadPlayer, files.Length);
        for (int i = 0; i < num; i++)
        {
            PlayerFileData fileData = Player.GetFileData(files[i], cloudSave: false);
            if (fileData != null)
            {
                PlayerList.Add(fileData);
            }
        }
        if (SocialAPI.Cloud != null)
        {
            foreach (string item in from path in SocialAPI.Cloud.GetFiles()
                where path.StartsWith(CloudPlayerPath, StringComparison.CurrentCultureIgnoreCase) && path.EndsWith(".plr", StringComparison.CurrentCultureIgnoreCase)
                select path)
            {
                PlayerFileData fileData2 = Player.GetFileData(item, cloudSave: true);
                if (fileData2 != null)
                {
                    PlayerList.Add(fileData2);
                }
            }
        }
        PlayerList.Sort(PlayerListSortMethod);
    }
 
    private static int PlayerListSortMethod(PlayerFileData data1, PlayerFileData data2)
    {
        return data1.Name.CompareTo(data2.Name);
    }
 
    protected void OpenRecent()
    {
        try
        {
            if (!File.Exists(SavePath + Path.DirectorySeparatorChar + "servers.dat"))
            {
                return;
            }
            using FileStream input = new FileStream(SavePath + Path.DirectorySeparatorChar + "servers.dat", FileMode.Open);
            using BinaryReader binaryReader = new BinaryReader(input);
            binaryReader.ReadInt32();
            for (int i = 0; i < 10; i++)
            {
                recentWorld[i] = binaryReader.ReadString();
                recentIP[i] = binaryReader.ReadString();
                recentPort[i] = binaryReader.ReadInt32();
            }
        }
        catch
        {
        }
    }
 
    public static void SaveRecent()
    {
        Utils.TryCreatingDirectory(SavePath);
        try
        {
            File.SetAttributes(SavePath + Path.DirectorySeparatorChar + "servers.dat", FileAttributes.Normal);
        }
        catch
        {
        }
        try
        {
            using FileStream output = new FileStream(SavePath + Path.DirectorySeparatorChar + "servers.dat", FileMode.Create);
            using BinaryWriter binaryWriter = new BinaryWriter(output);
            binaryWriter.Write(279);
            for (int i = 0; i < 10; i++)
            {
                binaryWriter.Write(recentWorld[i]);
                binaryWriter.Write(recentIP[i]);
                binaryWriter.Write(recentPort[i]);
            }
        }
        catch
        {
        }
    }
 
    public static bool SaveSettings()
    {
        Preferences configuration = Configuration;
        configuration.Clear();
        configuration.Put("ResetDefaultUIScale", false);
        configuration.Put("SmartCursorToggle", cSmartCursorModeIsToggleAndNotHold);
        configuration.Put("MapEnabled", mapEnabled);
        configuration.Put("InvasionBarMode", invasionProgressMode);
        configuration.Put("AutoSave", autoSave);
        configuration.Put("AutoPause", autoPause);
        configuration.Put("Language", Language.ActiveCulture.Name);
        configuration.Put("PlacementPreview", placementPreview);
        configuration.Put("GoreVisualsAllowed", ChildSafety.Disabled);
        configuration.Put("WorldRollbacksToKeep", WorldRollingBackupsCountToKeep);
        configuration.Put("TeamNameplateDistance", teamNamePlateDistance);
        configuration.Put("MultiplayerNPCSmoothingRange", multiplayerNPCSmoothingRange);
        configuration.Put("VolumeSound", soundVolume);
        configuration.Put("VolumeAmbient", ambientVolume);
        configuration.Put("VolumeMusic", musicVolume);
        configuration.Put("UnlockMusicSwap", TOWMusicUnlocked);
        configuration.Put("UseExperimentalFeatures", UseExperimentalFeatures);
        configuration.Put("KeyFavoriteModifier", cFavoriteKey);
        configuration.Put("Fullscreen", graphics.IsFullScreen);
        configuration.Put("WindowMaximized", screenMaximized);
        configuration.Put("WindowBorderless", screenBorderless);
        int num = graphics.PreferredBackBufferWidth;
        int num2 = graphics.PreferredBackBufferHeight;
        if (IsInTheMiddleOfLoadingSettings)
        {
            if (LastLoadedResolution.X != 0)
            {
                num = LastLoadedResolution.X;
            }
            if (LastLoadedResolution.Y != 0)
            {
                num2 = LastLoadedResolution.Y;
            }
        }
        configuration.Put("DisplayWidth", num);
        configuration.Put("DisplayHeight", num2);
        configuration.Put("GraphicsQuality", qaStyle);
        configuration.Put("BackgroundEnabled", BackgroundEnabled);
        configuration.Put("FrameSkipMode", FrameSkipMode);
        configuration.Put("LightingMode", Lighting.Mode);
        configuration.Put("BackgroundParallax", bgScroll);
        configuration.Put("ShowItemText", showItemText);
        configuration.Put("LastLaunchedVersion", 279);
        configuration.Put("ClientUUID", clientUUID);
        configuration.Put("UseSmartCursorForCommonBlocks", Player.SmartCursorSettings.SmartBlocksEnabled);
        configuration.Put("UseSmartAxeAfterSmartPickaxe", Player.SmartCursorSettings.SmartAxeAfterPickaxe);
        configuration.Put("SmartCursorHoldCanReleaseMidUse", Player.SmartCursorSettings.SmartCursorHoldCanReleaseMidUse);
        configuration.Put("DisableLeftShiftTrashCan", ItemSlot.Options.DisableLeftShiftTrashCan);
        configuration.Put("DisableQuickTrash", ItemSlot.Options.DisableQuickTrash);
        configuration.Put("HighlightNewItems", ItemSlot.Options.HighlightNewItems);
        configuration.Put("HidePasswords", HidePassword);
        configuration.Put("ReverseUpDownForArmorSetBonuses", ReversedUpDownArmorSetBonuses);
        configuration.Put("MouseShowBuildingGrid", MouseShowBuildingGrid);
        configuration.Put("AllowUnfocusedInputOnGamepad", AllowUnfocusedInputOnGamepad);
        configuration.Put("LockOnPriority", LockOnHelper.UseMode);
        configuration.Put("InvisibleCursorForGamepad", InvisibleCursorForGamepad);
        configuration.Put("GamepadDisableInstructionsDisplay", GamepadDisableInstructionsDisplay);
        configuration.Put("SettingsUnlock_WorldEvil", SettingsUnlock_WorldEvil);
        configuration.Put("SettingsEnabled_MinersWobble", SettingsEnabled_MinersWobble);
        configuration.Put("SettingBlockGamepadsEntirely", SettingBlockGamepadsEntirely);
        configuration.Put("SettingsEnabled_OpaqueBoxBehindTooltips", SettingsEnabled_OpaqueBoxBehindTooltips);
        configuration.Put("SettingDontScaleMainMenuUp", SettingDontScaleMainMenuUp);
        configuration.Put("SettingsEnabled_TilesSwayInWind", SettingsEnabled_TilesSwayInWind);
        configuration.Put("SettingsEnabled_AutoReuseAllItems", SettingsEnabled_AutoReuseAllItems);
        configuration.Put("UseStormEffect", UseStormEffects);
        configuration.Put("UseHeatDistortion", UseHeatDistortion);
        configuration.Put("WaveQuality", WaveQuality);
        configuration.Put("Support4K", Support4K);
        configuration.Put("MouseColor", new Dictionary<string, byte>
        {
            { "R", mouseColor.R },
            { "G", mouseColor.G },
            { "B", mouseColor.B }
        });
        configuration.Put("MouseBorderColor", new Dictionary<string, byte>
        {
            { "R", MouseBorderColor.R },
            { "G", MouseBorderColor.G },
            { "B", MouseBorderColor.B },
            { "A", MouseBorderColor.A }
        });
        configuration.Put("QuickLaunch", SkipAssemblyLoad);
        configuration.Put("Zoom", GameZoomTarget);
        configuration.Put("UIScale", _uiScaleWanted);
        configuration.Put("MapScale", MapScale);
        configuration.Put("FlashIconForEvents", Enum.GetName(typeof(GameNotificationType), _flashNotificationType));
        configuration.Put("Display", _windowMover.ScreenDeviceName);
        configuration.Put("DisplayScreen", _windowMover.ScreenDeviceName);
        configuration.Put("ThrottleWhenInactive", instance.InactiveSleepTime != TimeSpan.Zero);
        configuration.Put("DoorAutoOpeningMode", DoorOpeningHelper.PreferenceSettings);
        configuration.Put("HoverControlMode", Player.Settings.HoverControl);
        configuration.Put("WaterfallDrawLimit", instance.waterfallManager.maxWaterfallCount);
        configuration.Put("DisableIntenseVisualEffects", DisableIntenseVisualEffects);
        if (Configuration.Save())
        {
            return PlayerInput.Save();
        }
        return false;
    }
 
    protected void CheckBunny()
    {
        try
        {
            RegistryKey currentUser = Registry.CurrentUser;
            currentUser = currentUser.CreateSubKey("Software\\Terraria");
            if (currentUser != null && currentUser.GetValue("Bunny") != null && currentUser.GetValue("Bunny").ToString() == "1")
            {
                runningCollectorsEdition = true;
            }
        }
        catch
        {
            runningCollectorsEdition = false;
        }
    }
 
    private static void TryPickingDefaultUIScale(float displayHeight)
    {
        if (shouldSetDefaultUIScale)
        {
            newDefaultUIScale = displayHeight / 1080f * 1.1f;
            shouldSetDefaultUIScale = false;
            Configuration.Put("UIScale", newDefaultUIScale);
            Configuration.Save();
        }
    }
 
    protected void LoadSettings()
    {
        if (File.Exists(SavePath + Path.DirectorySeparatorChar + "config.dat"))
        {
            OpenLegacySettings();
            if (SaveSettings())
            {
                File.Delete(SavePath + Path.DirectorySeparatorChar + "config.dat");
            }
            return;
        }
        IsInTheMiddleOfLoadingSettings = true;
        Preferences configuration = Configuration;
        configuration.Load();
        int currentValue = 0;
        configuration.Get("LastLaunchedVersion", ref currentValue);
        bool flag = false;
        if (currentValue < 219)
        {
            flag = true;
        }
        if (!flag)
        {
            configuration.Get("ResetDefaultUIScale", ref shouldSetDefaultUIScale);
            configuration.Get("Fullscreen", ref startFullscreen);
            configuration.Get("WindowMaximized", ref screenMaximized);
            configuration.Get("WindowBorderless", ref screenBorderless);
        }
        PendingBorderlessState = screenBorderless;
        screenBorderlessPendingResizes = (screenBorderless ? 6 : 0);
        if (Platform.IsWindows && !dedServ)
        {
            Form form = (Form)Control.FromHandle(instance.Window.Handle);
            if (screenBorderless)
            {
                SetBorderlessFormStyle(form);
            }
            else if (screenMaximized)
            {
                form.FormBorderStyle = FormBorderStyle.Sizable;
                form.WindowState = FormWindowState.Maximized;
            }
            else
            {
                form.FormBorderStyle = FormBorderStyle.Sizable;
            }
            form.BringToFront();
        }
        int currentValue2 = graphics.PreferredBackBufferWidth;
        int currentValue3 = graphics.PreferredBackBufferHeight;
        configuration.Get("DisplayWidth", ref currentValue2);
        configuration.Get("DisplayHeight", ref currentValue3);
        LastLoadedResolution = new Microsoft.Xna.Framework.Point(currentValue2, currentValue3);
        if (!startFullscreen)
        {
            if (PendingBorderlessState)
            {
                screenBorderlessPendingResizes = 1;
            }
            SetDisplayMode(currentValue2, currentValue3, fullscreen: false);
            TryPickingDefaultUIScale(currentValue3);
        }
        configuration.Get("SmartCursorToggle", ref cSmartCursorModeIsToggleAndNotHold);
        configuration.Get("MapEnabled", ref mapEnabled);
        configuration.Get("InvasionBarMode", ref invasionProgressMode);
        configuration.Get("AutoSave", ref autoSave);
        configuration.Get("AutoPause", ref autoPause);
        _needsLanguageSelect = !configuration.Contains("Language");
        string text = configuration.Get("Language", "en-US");
        int result = 0;
        if (int.TryParse(text, out result))
        {
            LanguageManager.Instance.SetLanguage(result);
            SetTitle();
        }
        else
        {
            LanguageManager.Instance.SetLanguage(text);
            SetTitle();
        }
        configuration.Get("PlacementPreview", ref placementPreview);
        configuration.Get("GoreVisualsAllowed", ref ChildSafety.Disabled);
        configuration.Get("DisableIntenseVisualEffects", ref DisableIntenseVisualEffects);
        if (!flag)
        {
            configuration.Get("VolumeSound", ref soundVolume);
            configuration.Get("VolumeAmbient", ref ambientVolume);
            configuration.Get("VolumeMusic", ref musicVolume);
        }
        configuration.Get("KeyFavoriteModifier", ref cFavoriteKey);
        if (Enum.TryParse<Microsoft.Xna.Framework.Input.Keys>(cFavoriteKey, out var result2))
        {
            FavoriteKey = result2;
        }
        if (!flag)
        {
            configuration.Get("GraphicsQuality", ref qaStyle);
            configuration.Get("BackgroundEnabled", ref BackgroundEnabled);
        }
        if (configuration.GetAllKeys().Contains("FrameSkip"))
        {
            bool currentValue4 = false;
            configuration.Get("FrameSkip", ref currentValue4);
            terrariasFixedTiming = !currentValue4;
            if (terrariasFixedTiming)
            {
                FrameSkipMode = FrameSkipMode.Subtle;
            }
            else
            {
                FrameSkipMode = FrameSkipMode.On;
            }
        }
        int currentValue5 = (int)FrameSkipMode;
        configuration.Get("FrameSkipMode", ref currentValue5);
        if (currentValue5 < 0)
        {
            currentValue5 = 0;
        }
        if (currentValue5 > 2)
        {
            currentValue5 = 2;
        }
        FrameSkipMode = (FrameSkipMode)currentValue5;
        int currentValue6 = (int)Lighting.Mode;
        if (!flag)
        {
            configuration.Get("LightingMode", ref currentValue6);
        }
        Lighting.Mode = (LightMode)currentValue6;
        configuration.Get("UnlockMusicSwap", ref TOWMusicUnlocked);
        configuration.Get("Parallax", ref caveParallax);
        bgScroll = (int)((1f - caveParallax) * 500f);
        configuration.Get("BackgroundParallax", ref bgScroll);
        caveParallax = 1f - (float)bgScroll / 500f;
        configuration.Get("ShowItemText", ref showItemText);
        configuration.Get("ClientUUID", ref clientUUID);
        configuration.Get("UseSmartCursorForCommonBlocks", ref Player.SmartCursorSettings.SmartBlocksEnabled);
        configuration.Get("UseSmartAxeAfterSmartPickaxe", ref Player.SmartCursorSettings.SmartAxeAfterPickaxe);
        configuration.Get("SmartCursorHoldCanReleaseMidUse", ref Player.SmartCursorSettings.SmartCursorHoldCanReleaseMidUse);
        if (!flag)
        {
            configuration.Get("DisableLeftShiftTrashCan", ref ItemSlot.Options.DisableLeftShiftTrashCan);
        }
        if (!flag)
        {
            configuration.Get("DisableQuickTrash", ref ItemSlot.Options.DisableQuickTrash);
        }
        configuration.Get("HidePasswords", ref HidePassword);
        configuration.Get("HighlightNewItems", ref ItemSlot.Options.HighlightNewItems);
        configuration.Get("ReverseUpDownForArmorSetBonuses", ref ReversedUpDownArmorSetBonuses);
        configuration.Get("MouseShowBuildingGrid", ref MouseShowBuildingGrid);
        configuration.Get("AllowUnfocusedInputOnGamepad", ref AllowUnfocusedInputOnGamepad);
        configuration.Get("GamepadDisableInstructionsDisplay", ref GamepadDisableInstructionsDisplay);
        configuration.Get("SettingDontScaleMainMenuUp", ref SettingDontScaleMainMenuUp);
        configuration.Get("WorldRollbacksToKeep", ref WorldRollingBackupsCountToKeep);
        configuration.Get("TeamNameplateDistance", ref teamNamePlateDistance);
        if (currentValue < 230)
        {
            configuration.Get("MultiplayerNPCSmoothingRange", ref multiplayerNPCSmoothingRange);
        }
        configuration.Get("UseStormEffect", ref UseStormEffects);
        configuration.Get("UseHeatDistortion", ref UseHeatDistortion);
        configuration.Get("WaveQuality", ref WaveQuality);
        if (WaveQuality > 3)
        {
            WaveQuality = 3;
        }
        if (WaveQuality < 0)
        {
            WaveQuality = 0;
        }
        Dictionary<string, byte> currentValue7 = new Dictionary<string, byte>();
        configuration.Get("MouseColor", ref currentValue7);
        if (currentValue7.TryGetValue("R", out var value))
        {
            mouseColor.R = value;
        }
        if (currentValue7.TryGetValue("G", out value))
        {
            mouseColor.G = value;
        }
        if (currentValue7.TryGetValue("B", out value))
        {
            mouseColor.B = value;
        }
        currentValue7.Clear();
        configuration.Get("MouseBorderColor", ref currentValue7);
        if (currentValue7.TryGetValue("R", out value))
        {
            MouseBorderColor.R = value;
        }
        if (currentValue7.TryGetValue("G", out value))
        {
            MouseBorderColor.G = value;
        }
        if (currentValue7.TryGetValue("B", out value))
        {
            MouseBorderColor.B = value;
        }
        if (currentValue7.TryGetValue("A", out value))
        {
            MouseBorderColor.A = value;
        }
        configuration.Get("QuickLaunch", ref SkipAssemblyLoad);
        if (!flag)
        {
            GameZoomTarget = configuration.Get("Zoom", 1f);
        }
        if (!flag)
        {
            UIScale = configuration.Get("UIScale", Platform.Get<IWindowService>().GetScaling());
        }
        if (newDefaultUIScale > 0f)
        {
            UIScale = newDefaultUIScale;
            newDefaultUIScale = 0f;
        }
        MapScale = MathHelper.Clamp(configuration.Get("MapScale", InitialMapScale), 0.5f, 1f);
        int currentValue8 = -1;
        configuration.Get("LockOnPriority", ref currentValue8);
        if (currentValue8 < 0)
        {
            currentValue8 = 0;
        }
        if (currentValue8 > 2)
        {
            currentValue8 = 2;
        }
        LockOnHelper.UseMode = (LockOnHelper.LockOnMode)currentValue8;
        if (LockOnHelper.UseMode == LockOnHelper.LockOnMode.FocusTarget)
        {
            LockOnHelper.UseMode = LockOnHelper.LockOnMode.ThreeDS;
        }
        configuration.Get("InvisibleCursorForGamepad", ref InvisibleCursorForGamepad);
        if (Enum.TryParse<GameNotificationType>(configuration.Get("FlashIconForEvents", "All"), out var result3))
        {
            _flashNotificationType = result3;
        }
        if (!flag)
        {
            string screenDeviceName = configuration.Get("DisplayScreen", "");
            _windowMover.TryMovingToScreen(screenDeviceName);
            bool flag2 = configuration.Get("ThrottleWhenInactive", defaultValue: true);
            base.InactiveSleepTime = TimeSpan.FromMilliseconds(flag2 ? 20 : 0);
        }
        if (!flag)
        {
            configuration.Get("Support4K", ref Support4K);
        }
        configuration.Get("UseExperimentalFeatures", ref UseExperimentalFeatures);
        configuration.Get("SettingsUnlock_WorldEvil", ref SettingsUnlock_WorldEvil);
        configuration.Get("SettingsEnabled_MinersWobble", ref SettingsEnabled_MinersWobble);
        configuration.Get("SettingBlockGamepadsEntirely", ref SettingBlockGamepadsEntirely);
        configuration.Get("SettingsEnabled_OpaqueBoxBehindTooltips", ref SettingsEnabled_OpaqueBoxBehindTooltips);
        configuration.Get("SettingsEnabled_TilesSwayInWind", ref SettingsEnabled_TilesSwayInWind);
        configuration.Get("SettingsEnabled_AutoReuseAllItems", ref SettingsEnabled_AutoReuseAllItems);
        int currentValue9 = (int)DoorOpeningHelper.PreferenceSettings;
        configuration.Get("DoorAutoOpeningMode", ref currentValue9);
        DoorOpeningHelper.PreferenceSettings = (DoorOpeningHelper.DoorAutoOpeningPreference)currentValue9;
        int currentValue10 = (int)Player.Settings.HoverControl;
        configuration.Get("HoverControlMode", ref currentValue10);
        Player.Settings.HoverControl = (Player.Settings.HoverControlMode)currentValue10;
        if (currentValue <= 147)
        {
            terrariasFixedTiming = !terrariasFixedTiming;
        }
        if (currentValue <= 162)
        {
            bool currentValue11 = false;
            uint currentValue12 = 0u;
            configuration.Get("ThickMouseEdges", ref currentValue11);
            if (currentValue11)
            {
                configuration.Get("ThickMouseEdgesPackedColor", ref currentValue12);
                MouseBorderColor.PackedValue = currentValue12;
                mouseColor.R = configuration.Get("MouseColorR", mouseColor.R);
                mouseColor.G = configuration.Get("MouseColorG", mouseColor.G);
                mouseColor.B = configuration.Get("MouseColorB", mouseColor.B);
            }
        }
        if (currentValue <= 162)
        {
            configuration.Get("KeyUp", ref cUp);
            configuration.Get("KeyDown", ref cDown);
            configuration.Get("KeyLeft", ref cLeft);
            configuration.Get("KeyRight", ref cRight);
            configuration.Get("KeyJump", ref cJump);
            configuration.Get("KeyThrowItem", ref cThrowItem);
            configuration.Get("KeyInventory", ref cInv);
            configuration.Get("KeyQuickHeal", ref cHeal);
            configuration.Get("KeyQuickMana", ref cMana);
            configuration.Get("KeyQuickBuff", ref cBuff);
            configuration.Get("KeyUseHook", ref cHook);
            configuration.Get("KeyAutoSelect", ref cTorch);
            configuration.Get("KeySmartCursor", ref cSmart);
            configuration.Get("KeyMount", ref cMount);
            configuration.Get("KeyMapStyle", ref cMapStyle);
            configuration.Get("KeyFullscreenMap", ref cMapFull);
            configuration.Get("KeyMapZoomIn", ref cMapZoomIn);
            configuration.Get("KeyMapZoomOut", ref cMapZoomOut);
            configuration.Get("KeyMapAlphaUp", ref cMapAlphaUp);
            configuration.Get("KeyMapAlphaDown", ref cMapAlphaDown);
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Up"] = new List<string> { cUp };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Down"] = new List<string> { cDown };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Left"] = new List<string> { cLeft };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Right"] = new List<string> { cRight };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Jump"] = new List<string> { cJump };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Throw"] = new List<string> { cThrowItem };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Inventory"] = new List<string> { cInv };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["QuickHeal"] = new List<string> { cHeal };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["QuickMana"] = new List<string> { cMana };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["QuickBuff"] = new List<string> { cBuff };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["Grapple"] = new List<string> { cHook };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["SmartSelect"] = new List<string> { cTorch };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["SmartCursor"] = new List<string> { cSmart };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["QuickMount"] = new List<string> { cMount };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["MapStyle"] = new List<string> { cMapStyle };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["MapFull"] = new List<string> { cMapFull };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["MapZoomIn"] = new List<string> { cMapZoomIn };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["MapZoomOut"] = new List<string> { cMapZoomOut };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["MapAlphaUp"] = new List<string> { cMapAlphaUp };
            PlayerInput.CurrentProfile.InputModes[InputMode.Keyboard].KeyStatus["MapAlphaDown"] = new List<string> { cMapAlphaDown };
        }
        PlayerInput.Load();
        if (currentValue < 165)
        {
            try
            {
                PlayerInput.ManageVersion_1_3();
            }
            catch (Exception)
            {
            }
        }
        mouseColorSlider.SetHSL(mouseColor);
        mouseBorderColorSlider.SetHSL(MouseBorderColor);
        mouseBorderColorSlider.Alpha = (float)(int)MouseBorderColor.A / 255f;
        if (currentValue != 279)
        {
            SaveSettings();
        }
        IsInTheMiddleOfLoadingSettings = false;
    }
 
    protected void OpenLegacySettings()
    {
        try
        {
            if (!File.Exists(SavePath + Path.DirectorySeparatorChar + "config.dat"))
            {
                return;
            }
            using FileStream input = new FileStream(SavePath + Path.DirectorySeparatorChar + "config.dat", FileMode.Open);
            using BinaryReader binaryReader = new BinaryReader(input);
            int num = binaryReader.ReadInt32();
            if (num >= 68)
            {
                if (num >= 67)
                {
                    clientUUID = binaryReader.ReadString();
                }
                bool flag = binaryReader.ReadBoolean();
                mouseColor.R = binaryReader.ReadByte();
                mouseColor.G = binaryReader.ReadByte();
                mouseColor.B = binaryReader.ReadByte();
                soundVolume = binaryReader.ReadSingle();
                if (num >= 90)
                {
                    ambientVolume = binaryReader.ReadSingle();
                }
                musicVolume = binaryReader.ReadSingle();
                cUp = binaryReader.ReadString();
                cDown = binaryReader.ReadString();
                cLeft = binaryReader.ReadString();
                cRight = binaryReader.ReadString();
                cJump = binaryReader.ReadString();
                cThrowItem = binaryReader.ReadString();
                if (num >= 1)
                {
                    cInv = binaryReader.ReadString();
                }
                if (num >= 12)
                {
                    cHeal = binaryReader.ReadString();
                    cMana = binaryReader.ReadString();
                    cBuff = binaryReader.ReadString();
                }
                if (num >= 13)
                {
                    cHook = binaryReader.ReadString();
                }
                caveParallax = binaryReader.ReadSingle();
                if (num >= 2)
                {
                    terrariasFixedTiming = binaryReader.ReadBoolean();
                }
                if (num >= 91 && binaryReader.ReadBoolean() && !dedServ && Platform.IsWindows)
                {
                    ((Form)Control.FromHandle(base.Window.Handle)).WindowState = FormWindowState.Maximized;
                }
                if (num >= 4)
                {
                    int width = binaryReader.ReadInt32();
                    int height = binaryReader.ReadInt32();
                    SetDisplayMode(width, height, flag);
                }
                if (num >= 8)
                {
                    autoSave = binaryReader.ReadBoolean();
                }
                if (num >= 9)
                {
                    autoPause = binaryReader.ReadBoolean();
                }
                if (num >= 19)
                {
                    showItemText = binaryReader.ReadBoolean();
                }
                if (num >= 30)
                {
                    cTorch = binaryReader.ReadString();
                    Lighting.Mode = (LightMode)binaryReader.ReadByte();
                    qaStyle = binaryReader.ReadByte();
                }
                if (num >= 37)
                {
                    BackgroundEnabled = binaryReader.ReadBoolean();
                }
                if (num >= 39)
                {
                    byte b = binaryReader.ReadByte();
                    _needsLanguageSelect = b == 0;
                    LanguageManager.Instance.SetLanguage(b);
                }
                if (num >= 46)
                {
                    mapEnabled = binaryReader.ReadBoolean();
                    cMapStyle = binaryReader.ReadString();
                    cMapFull = binaryReader.ReadString();
                    cMapZoomIn = binaryReader.ReadString();
                    cMapZoomOut = binaryReader.ReadString();
                    cMapAlphaUp = binaryReader.ReadString();
                    cMapAlphaDown = binaryReader.ReadString();
                }
                if (num >= 89)
                {
                    binaryReader.ReadInt32();
                }
                if (num >= 100)
                {
                    cSmart = binaryReader.ReadString();
                    cSmartCursorModeIsToggleAndNotHold = binaryReader.ReadBoolean();
                }
                if (num >= 107)
                {
                    invasionProgressMode = binaryReader.ReadByte();
                }
                if (num >= 111)
                {
                    placementPreview = binaryReader.ReadBoolean();
                }
                if (num >= 111)
                {
                    placementPreview = binaryReader.ReadBoolean();
                }
                SetFullScreen(flag);
            }
            binaryReader.Close();
        }
        catch
        {
        }
    }
 
    private static void ErasePlayer(int i)
    {
        try
        {
            FileUtilities.Delete(PlayerList[i].Path, PlayerList[i].IsCloudSave);
            FileUtilities.Delete(PlayerList[i].Path + ".bak", PlayerList[i].IsCloudSave);
        }
        catch
        {
        }
        try
        {
            string text = PlayerList[i].Path.Substring(0, PlayerList[i].Path.Length - 4);
            if (text.Substring(text.Length - 1) != "." && text.Substring(text.Length - 1) != "\\" && Directory.Exists(text))
            {
                Directory.Delete(text, recursive: true);
            }
            LoadPlayers();
        }
        catch
        {
        }
    }
 
    private static void EraseWorld(int i)
    {
        try
        {
            if (!WorldList[i].IsCloudSave)
            {
                Platform.Get<IPathService>().MoveToRecycleBin(WorldList[i].Path);
                Platform.Get<IPathService>().MoveToRecycleBin(WorldList[i].Path + ".bak");
                for (int j = 2; j <= 9; j++)
                {
                    Platform.Get<IPathService>().MoveToRecycleBin(WorldList[i].Path + ".bak" + j);
                }
            }
            else if (SocialAPI.Cloud != null)
            {
                SocialAPI.Cloud.Delete(WorldList[i].Path);
            }
            LoadWorlds();
        }
        catch
        {
        }
    }
 
    public static string GetPlayerPathFromName(string playerName, bool cloudSave)
    {
        char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
        string text = "";
        playerName = playerName.Replace(".", "_");
        playerName = playerName.Replace("*", "_");
        foreach (char c in playerName)
        {
            text += ((!invalidFileNameChars.Contains(c)) ? ((c != ' ') ? c : '_') : '-');
        }
        string text2 = (cloudSave ? CloudPlayerPath : PlayerPath);
        if (FileUtilities.GetFullPath(text2 + Path.DirectorySeparatorChar + text + ".plr", cloudSave).StartsWith("\\\\.\\", StringComparison.Ordinal))
        {
            text += "_";
        }
        if (FileUtilities.Exists(text2 + Path.DirectorySeparatorChar + text + ".plr", cloudSave))
        {
            int num = 2;
            while (FileUtilities.Exists(text2 + Path.DirectorySeparatorChar.ToString() + text + num + ".plr", cloudSave))
            {
                num++;
            }
            text += num;
        }
        return text2 + Path.DirectorySeparatorChar + text + ".plr";
    }
 
    public static string GetWorldPathFromName(string worldName, bool cloudSave)
    {
        char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
        string text = "";
        foreach (char c in worldName)
        {
            text += ((!invalidFileNameChars.Contains(c)) ? ((c != ' ') ? c : '_') : '-');
        }
        text = text.Replace(".", "_");
        text = text.Replace("*", "_");
        string text2 = (cloudSave ? CloudWorldPath : WorldPath);
        if (FileUtilities.GetFullPath(text2 + Path.DirectorySeparatorChar + text + ".wld", cloudSave).StartsWith("\\\\.\\", StringComparison.Ordinal))
        {
            text += "_";
        }
        if (FileUtilities.Exists(text2 + Path.DirectorySeparatorChar + text + ".wld", cloudSave))
        {
            int num = 2;
            while (FileUtilities.Exists(text2 + Path.DirectorySeparatorChar.ToString() + text + num + ".wld", cloudSave))
            {
                num++;
            }
            text += num;
        }
        return text2 + Path.DirectorySeparatorChar + text + ".wld";
    }
 
    public void setServerWorldRollbacks(string rollBacksToKeep)
    {
        WorldRollingBackupsCountToKeep = Convert.ToInt32(rollBacksToKeep);
    }
 
    public void autoCreate(string worldSize)
    {
        switch (worldSize)
        {
        case "0":
            autoGen = false;
            break;
        case "1":
            maxTilesX = 4200;
            maxTilesY = 1200;
            autoGen = true;
            break;
        case "2":
            maxTilesX = 6400;
            maxTilesY = 1800;
            autoGen = true;
            break;
        case "3":
            maxTilesX = 8400;
            maxTilesY = 2400;
            autoGen = true;
            break;
        }
    }
 
    public void NewMOTD(string newMOTD)
    {
        motd = newMOTD;
    }
 
    public static string ConvertToSafeArgument(string arg)
    {
        return Uri.EscapeDataString(arg);
    }
 
    public static string ConvertFromSafeArgument(string arg)
    {
        return Uri.UnescapeDataString(arg);
    }
 
    public void LoadDedConfig(string configPath)
    {
        if (!File.Exists(configPath))
        {
            return;
        }
        using StreamReader streamReader = new StreamReader(configPath);
        string text;
        while ((text = streamReader.ReadLine()) != null)
        {
            try
            {
                if (text.Length > 6 && text.Substring(0, 6).ToLower() == "world=")
                {
                    string text2 = text.Substring(6);
                    try
                    {
                        string text3 = Platform.Get<IPathService>().ExpandPathVariables(text2);
                        new FileInfo(text3);
                        autoGenFileLocation = text3;
                        ActiveWorldFileData = WorldFile.GetAllMetadata(text3, cloudSave: false);
                    }
                    catch
                    {
                    }
                }
                if (text.Length > 5 && text.Substring(0, 5).ToLower() == "port=")
                {
                    string value = text.Substring(5);
                    try
                    {
                        Netplay.ListenPort = Convert.ToInt32(value);
                    }
                    catch
                    {
                    }
                }
                if (text.Length > 21 && text.Substring(0, 21).ToLower() == "worldrollbackstokeep=")
                {
                    string value2 = text.Substring(21);
                    try
                    {
                        WorldRollingBackupsCountToKeep = Convert.ToInt32(value2);
                    }
                    catch
                    {
                    }
                }
                if (text.Length > 11 && text.Substring(0, 11).ToLower() == "maxplayers=")
                {
                    string value3 = text.Substring(11);
                    try
                    {
                        int num = Convert.ToInt32(value3);
                        if (num <= 255 && num >= 1)
                        {
                            SetNetPlayers(num);
                        }
                    }
                    catch
                    {
                    }
                }
                if (text.Length > 11 && text.Substring(0, 9).ToLower() == "priority=" && !Program.LaunchParameters.ContainsKey("-forcepriority"))
                {
                    string value4 = text.Substring(9);
                    try
                    {
                        int num2 = Convert.ToInt32(value4);
                        if (num2 >= 0 && num2 <= 5)
                        {
                            Process currentProcess = Process.GetCurrentProcess();
                            switch (num2)
                            {
                            case 0:
                                currentProcess.PriorityClass = ProcessPriorityClass.RealTime;
                                break;
                            case 1:
                                currentProcess.PriorityClass = ProcessPriorityClass.High;
                                break;
                            case 2:
                                currentProcess.PriorityClass = ProcessPriorityClass.AboveNormal;
                                break;
                            case 3:
                                currentProcess.PriorityClass = ProcessPriorityClass.Normal;
                                break;
                            case 4:
                                currentProcess.PriorityClass = ProcessPriorityClass.BelowNormal;
                                break;
                            case 5:
                                currentProcess.PriorityClass = ProcessPriorityClass.Idle;
                                break;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
                if (text.Length > 9 && text.Substring(0, 9).ToLower() == "password=")
                {
                    Netplay.ServerPassword = ConvertFromSafeArgument(text.Substring(9));
                }
                if (text.Length > 5 && text.Substring(0, 5).ToLower() == "motd=")
                {
                    motd = text.Substring(5);
                }
                if (text.Length > 5 && text.Substring(0, 5).ToLower() == "lang=")
                {
                    string value5 = text.Substring(5);
                    LanguageManager.Instance.SetLanguage(Convert.ToInt32(value5));
                }
                if (text.Length > 5 && text.Substring(0, 5).ToLower() == "language=")
                {
                    string language = text.Substring(9);
                    LanguageManager.Instance.SetLanguage(language);
                }
                if (text.Length >= 10 && text.Substring(0, 10).ToLower() == "worldpath=")
                {
                    string text4 = text.Substring(10);
                    WorldPath = Platform.Get<IPathService>().ExpandPathVariables(text4);
                }
                if (text.Length >= 10 && text.Substring(0, 10).ToLower() == "worldname=")
                {
                    worldName = text.Substring(10);
                }
                if (text.Length >= 5 && text.Substring(0, 5).ToLower() == "seed=")
                {
                    AutogenSeedName = text.Substring(5);
                }
                if (text.Length > 8 && text.Substring(0, 8).ToLower() == "banlist=")
                {
                    string text5 = text.Substring(8);
                    Netplay.BanFilePath = Platform.Get<IPathService>().ExpandPathVariables(text5);
                }
                if (text.Length > 11 && text.Substring(0, 11).ToLower() == "difficulty=")
                {
                    switch (text.Substring(11))
                    {
                    case "0":
                        GameMode = 0;
                        break;
                    case "1":
                        GameMode = 1;
                        break;
                    case "2":
                        GameMode = 2;
                        break;
                    case "3":
                        GameMode = 3;
                        break;
                    }
                }
                if (text.Length > 11 && text.Substring(0, 11).ToLower() == "autocreate=")
                {
                    string worldSize = text.Substring(11);
                    autoCreate(worldSize);
                }
                if (text.Length > 7 && text.Substring(0, 7).ToLower() == "secure=" && text.Substring(7) == "1")
                {
                    Netplay.SpamCheck = true;
                }
                if (text.Length > 5 && text.Substring(0, 5).ToLower() == "upnp=" && text.Substring(5) != "1")
                {
                    Netplay.UseUPNP = false;
                }
                string text6 = "slowliquids=";
                if (text.Length > text6.Length && text.Substring(0, text6.Length).ToLower() == text6 && text.Substring(text6.Length) == "1")
                {
                    Setting_UseReducedMaxLiquids = true;
                }
                if (text.Length > 10 && text.Substring(0, 10).ToLower() == "npcstream=")
                {
                    string value6 = text.Substring(10);
                    try
                    {
                        npcStreamSpeed = Convert.ToInt32(value6);
                    }
                    catch
                    {
                    }
                }
                CreativePowerManager.TryListingPermissionsFrom(text);
            }
            catch
            {
            }
        }
    }
 
    public void SetNetPlayers(int mPlayers)
    {
        maxNetPlayers = mPlayers;
    }
 
    public void SetWorld(string world, bool cloud)
    {
        ActiveWorldFileData = WorldFile.GetAllMetadata(world, cloud);
    }
 
    public void SetWorldName(string world)
    {
        worldName = world;
    }
 
    public void EnableAutoShutdown()
    {
        autoShutdown = true;
    }
 
    [DllImport("user32.dll")]
    public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
 
    [DllImport("user32.dll")]
    private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
 
    public void AutoPass()
    {
        autoPass = true;
    }
 
    public void AutoJoin(string IP)
    {
        defaultIP = IP;
        getIP = IP;
        Netplay.SetRemoteIP(defaultIP);
        autoJoin = true;
    }
 
    public void AutoHost()
    {
        menuMultiplayer = true;
        menuServer = true;
        ClearPendingPlayerSelectCallbacks();
        menuMode = 1;
    }
 
    public void loadLib(string path)
    {
        libPath = path;
        LoadLibrary(libPath);
    }
 
    public void NeverSleep()
    {
        if (Platform.IsWindows)
        {
            previousExecutionState = NativeMethods.SetThreadExecutionState(2147483649u);
        }
    }
 
    public void YouCanSleepNow()
    {
        if (Platform.IsWindows && previousExecutionState != 0)
        {
            NativeMethods.SetThreadExecutionState(previousExecutionState);
        }
    }
 
    public void DedServ()
    {
        NeverSleep();
        rand = new UnifiedRandom();
        if (autoShutdown)
        {
            string lpWindowName = (Console.Title = "terraria" + rand.Next(int.MaxValue));
            if (Platform.IsWindows)
            {
                IntPtr intPtr = FindWindow(null, lpWindowName);
                if (intPtr != IntPtr.Zero)
                {
                    ShowWindow(intPtr, 0);
                }
            }
        }
        else
        {
            Console.Title = "Terraria Server " + versionNumber2;
        }
        dedServ = true;
        showSplash = false;
        Initialize();
        while (worldPathName == null || worldPathName == "")
        {
            bool flag = true;
            while (flag)
            {
                LoadWorlds();
                Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                Console.WriteLine("");
                for (int i = 0; i < WorldList.Count; i++)
                {
                    Console.WriteLine(i + 1 + "\t\t" + WorldList[i].Name);
                }
                string textValue = Language.GetTextValue("CLI.NewWorld_Command");
                string textValue2 = Language.GetTextValue("CLI.DeleteWorld_Example");
                int num = (Math.Max(newWorldName.Length, textValue2.Length) + 1) / 8 + 1;
                textValue = textValue + new string('\t', num - textValue.Length / 8) + Language.GetTextValue("CLI.NewWorld_Description");
                textValue2 = textValue2 + new string('\t', num - textValue2.Length / 8) + Language.GetTextValue("CLI.DeleteWorld_Description");
                Console.WriteLine(textValue);
                Console.WriteLine(textValue2);
                Console.WriteLine("");
                Console.Write(Language.GetTextValue("CLI.ChooseWorld"));
                string text2 = ReadLineInput();
                if (text2 == null)
                {
                    text2 = "";
                }
                try
                {
                    Console.Clear();
                }
                catch
                {
                }
                if (text2.StartsWith(Language.GetTextValue("CLI.DeleteWorld_Command") + " "))
                {
                    try
                    {
                        int length = Language.GetTextValue("CLI.DeleteWorld_Command").Length;
                        int num2 = Convert.ToInt32(text2.Substring(length + 1)) - 1;
                        if (num2 < WorldList.Count)
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                            Console.WriteLine("");
                            Console.WriteLine(Language.GetTextValue("CLI.DeleteConfirmation", WorldList[num2].Name));
                            Console.Write("({0}/{1}): ", Language.GetTextValue("CLI.ShortYes"), Language.GetTextValue("CLI.ShortNo"));
                            if (ReadLineInput().ToLower() == Language.GetTextValue("CLI.ShortYes").ToLower())
                            {
                                EraseWorld(num2);
                            }
                        }
                    }
                    catch
                    {
                    }
                    try
                    {
                        Console.Clear();
                    }
                    catch
                    {
                    }
                    continue;
                }
                if (text2 == "n" || text2 == "N")
                {
                    bool flag2 = true;
                    while (flag2)
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        Console.WriteLine("");
                        Console.WriteLine("1\t" + Language.GetTextValue("UI.WorldSizeSmall"));
                        Console.WriteLine("2\t" + Language.GetTextValue("UI.WorldSizeMedium"));
                        Console.WriteLine("3\t" + Language.GetTextValue("UI.WorldSizeLarge"));
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.ChooseSize"));
                        string value = ReadLineInput();
                        try
                        {
                            switch (Convert.ToInt32(value))
                            {
                            case 1:
                                maxTilesX = 4200;
                                maxTilesY = 1200;
                                flag2 = false;
                                break;
                            case 2:
                                maxTilesX = 6400;
                                maxTilesY = 1800;
                                flag2 = false;
                                break;
                            case 3:
                                maxTilesX = 8400;
                                maxTilesY = 2400;
                                flag2 = false;
                                break;
                            }
                        }
                        catch
                        {
                        }
                        try
                        {
                            Console.Clear();
                        }
                        catch
                        {
                        }
                    }
                    flag2 = true;
                    while (flag2)
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        Console.WriteLine("");
                        Console.WriteLine("1\t" + Language.GetTextValue("UI.Normal"));
                        Console.WriteLine("2\t" + Language.GetTextValue("UI.Expert"));
                        Console.WriteLine("3\t" + Language.GetTextValue("UI.Master"));
                        Console.WriteLine("4\t" + Language.GetTextValue("UI.Creative"));
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.ChooseDifficulty"));
                        string value = ReadLineInput();
                        try
                        {
                            switch (Convert.ToInt32(value))
                            {
                            case 1:
                                GameMode = 0;
                                flag2 = false;
                                break;
                            case 2:
                                GameMode = 1;
                                flag2 = false;
                                break;
                            case 3:
                                GameMode = 2;
                                flag2 = false;
                                break;
                            case 4:
                                GameMode = 3;
                                flag2 = false;
                                break;
                            }
                        }
                        catch
                        {
                        }
                        try
                        {
                            Console.Clear();
                        }
                        catch
                        {
                        }
                    }
                    flag2 = true;
                    while (flag2)
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        Console.WriteLine("");
                        Console.WriteLine("1\t" + Language.GetTextValue("CLI.Random"));
                        Console.WriteLine("2\t" + Language.GetTextValue("CLI.Corrupt"));
                        Console.WriteLine("3\t" + Language.GetTextValue("CLI.Crimson"));
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.ChooseEvil"));
                        string value = ReadLineInput();
                        try
                        {
                            switch (Convert.ToInt32(value))
                            {
                            case 1:
                                WorldGen.WorldGenParam_Evil = -1;
                                flag2 = false;
                                break;
                            case 2:
                                WorldGen.WorldGenParam_Evil = 0;
                                flag2 = false;
                                break;
                            case 3:
                                WorldGen.WorldGenParam_Evil = 1;
                                flag2 = false;
                                break;
                            }
                        }
                        catch
                        {
                        }
                        try
                        {
                            Console.Clear();
                        }
                        catch
                        {
                        }
                    }
                    flag2 = true;
                    Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                    while (flag2)
                    {
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.EnterWorldName"));
                        newWorldName = ReadLineInput();
                        if (newWorldName != null && newWorldName != "" && newWorldName != " ")
                        {
                            if (newWorldName.Length >= 27)
                            {
                                Console.WriteLine("");
                                Console.WriteLine(Language.GetTextValue("CLI.WorldNameLengthTooLong", 26));
                                continue;
                            }
                            flag2 = false;
                            try
                            {
                                Console.Clear();
                            }
                            catch
                            {
                            }
                        }
                        else
                        {
                            try
                            {
                                Console.Clear();
                            }
                            catch
                            {
                            }
                            Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        }
                    }
                    string text3 = "";
                    flag2 = true;
                    Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                    while (flag2)
                    {
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.EnterSeed"));
                        text3 = ReadLineInput();
                        if (text3 != null)
                        {
                            if (text3.Length >= 40)
                            {
                                Console.WriteLine("");
                                Console.WriteLine(Language.GetTextValue("CLI.SeedLengthTooLong", 39));
                                continue;
                            }
                            flag2 = false;
                            try
                            {
                                Console.Clear();
                            }
                            catch
                            {
                            }
                        }
                        else
                        {
                            text3 = "";
                        }
                    }
                    worldName = newWorldName;
                    ActiveWorldFileData = WorldFile.CreateMetadata(worldName, SocialAPI.Cloud != null && SocialAPI.Cloud.EnabledByDefault, GameMode);
                    text3 = text3.Trim();
                    if (text3.Length == 0)
                    {
                        ActiveWorldFileData.SetSeedToRandom();
                    }
                    else
                    {
                        ActiveWorldFileData.SetSeed(text3);
                    }
                    UIWorldCreation.ProcessSpecialWorldSeeds(text3);
                    menuMode = 10;
                    GenerationProgress generationProgress = new GenerationProgress();
                    Task task = WorldGen.CreateNewWorld(generationProgress);
                    flag2 = false;
                    while (menuMode == 10)
                    {
                        if (oldStatusText != statusText && !WorldGen.drunkWorldGen)
                        {
                            oldStatusText = statusText;
                            Console.WriteLine(statusText);
                        }
                    }
                    try
                    {
                        Console.Clear();
                    }
                    catch
                    {
                    }
                    while (!task.IsCompleted)
                    {
                        statusText = string.Format("{0:0.0%} - " + generationProgress.Message + " - {1:0.0%}", generationProgress.TotalProgress, generationProgress.Value);
                        if (oldStatusText != statusText)
                        {
                            oldStatusText = statusText;
                            string value2 = statusText;
                            if (WorldGen.notTheBees && !WorldGen.getGoodWorldGen)
                            {
                                value2 = string.Format("{0:0.0%} - " + Language.GetTextValue("UI.WorldGenEasterEgg_GeneratingBees") + " - {1:0.0%}", generationProgress.TotalProgress, generationProgress.Value);
                            }
                            Console.WriteLine(value2);
                        }
                    }
                    continue;
                }
                try
                {
                    int num3 = Convert.ToInt32(text2);
                    num3--;
                    if (num3 < 0 || num3 >= WorldList.Count)
                    {
                        continue;
                    }
                    bool flag3 = true;
                    while (flag3)
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.SetInitialMaxPlayers"));
                        string text4 = ReadLineInput();
                        try
                        {
                            if (text4 == "")
                            {
                                text4 = "16";
                            }
                            int num4 = Convert.ToInt32(text4);
                            if (num4 <= 255 && num4 >= 1)
                            {
                                SetNetPlayers(num4);
                                flag3 = false;
                            }
                            flag3 = false;
                        }
                        catch
                        {
                        }
                        try
                        {
                            Console.Clear();
                        }
                        catch
                        {
                        }
                    }
                    flag3 = true;
                    while (flag3)
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.SetInitialPort"));
                        string text5 = ReadLineInput();
                        try
                        {
                            if (text5 == "")
                            {
                                text5 = "7777";
                            }
                            int num5 = Convert.ToInt32(text5);
                            if (num5 <= 65535)
                            {
                                Netplay.ListenPort = num5;
                                flag3 = false;
                            }
                        }
                        catch
                        {
                        }
                        try
                        {
                            Console.Clear();
                        }
                        catch
                        {
                        }
                    }
                    flag3 = true;
                    while (flag3)
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                        Console.WriteLine("");
                        Console.Write(Language.GetTextValue("CLI.AutomaticPortForward", Language.GetTextValue("CLI.ShortYes"), Language.GetTextValue("CLI.ShortNo")));
                        string text6 = ReadLineInput();
                        try
                        {
                            if (text6 == "" || text6.ToLower() == Language.GetTextValue("CLI.ShortYes").ToLower() || text6.ToLower() == Language.GetTextValue("CLI.Yes").ToLower())
                            {
                                Netplay.UseUPNP = true;
                                flag3 = false;
                            }
                            else if (text6.ToLower() == Language.GetTextValue("CLI.ShortNo").ToLower() || text6.ToLower() == Language.GetTextValue("CLI.No").ToLower())
                            {
                                Netplay.UseUPNP = false;
                                flag3 = false;
                            }
                        }
                        catch
                        {
                        }
                        try
                        {
                            Console.Clear();
                        }
                        catch
                        {
                        }
                    }
                    Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber2));
                    Console.WriteLine("");
                    Console.Write(Language.GetTextValue("CLI.EnterServerPassword"));
                    Netplay.ServerPassword = ReadLineInput();
                    ActiveWorldFileData = WorldList[num3];
                    flag = false;
                    try
                    {
                        Console.Clear();
                    }
                    catch
                    {
                    }
                }
                catch
                {
                }
            }
        }
        try
        {
            Console.Clear();
        }
        catch
        {
        }
        Task task2 = WorldGen.serverLoadWorld();
        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber));
        Console.WriteLine("");
        while (!task2.IsCompleted)
        {
            if (WorldFile.LastThrownLoadException == null)
            {
                if (AutogenProgress.TotalProgress != 0.0)
                {
                    statusText = string.Format("{0:0.0%} - " + AutogenProgress.Message + " - {1:0.0%}", AutogenProgress.TotalProgress, AutogenProgress.Value);
                }
                if (oldStatusText != statusText)
                {
                    oldStatusText = statusText;
                    Console.WriteLine(statusText);
                }
            }
        }
        try
        {
            if (WorldFile.LastThrownLoadException == null)
            {
                Console.Clear();
            }
        }
        catch
        {
        }
        if (WorldGen.loadFailed || !WorldGen.loadSuccess)
        {
            WriteFancyWorldLoadErrorToConsole();
            if (!autoShutdown)
            {
                Console.ReadKey();
            }
            YouCanSleepNow();
            return;
        }
        Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber));
        Console.WriteLine("");
        Console.WriteLine(Language.GetTextValue("CLI.ListeningOnPort", Netplay.ListenPort));
        Console.WriteLine(Language.GetTextValue("CLI.HelpHint"));
        Console.WriteLine("");
        Console.Title = "Terraria Server: " + worldName;
        Stopwatch stopwatch = new Stopwatch();
        if (!autoShutdown)
        {
            startDedInput();
        }
        stopwatch.Start();
        double num6 = 16.666666666666668;
        double num7 = 0.0;
        int num8 = 0;
        new Stopwatch().Start();
        Netplay.StartServer();
        gameMenu = false;
        while (!Netplay.Disconnect)
        {
            double totalMilliseconds = stopwatch.Elapsed.TotalMilliseconds;
            if (totalMilliseconds + num7 >= num6)
            {
                num8++;
                num7 += totalMilliseconds - num6;
                stopwatch.Reset();
                stopwatch.Start();
                if (oldStatusText != statusText)
                {
                    oldStatusText = statusText;
                    Console.WriteLine(statusText);
                }
                if (Netplay.HasClients)
                {
                    Update(new GameTime());
                }
                else if (saveTime.IsRunning)
                {
                    saveTime.Stop();
                }
                if (Main.OnTickForThirdPartySoftwareOnly != null)
                {
                    Main.OnTickForThirdPartySoftwareOnly();
                }
                double num9 = stopwatch.Elapsed.TotalMilliseconds + num7;
                if (num9 < num6)
                {
                    int num10 = (int)(num6 - num9) - 1;
                    if (num10 > 1)
                    {
                        Thread.Sleep(num10 - 1);
                        if (!Netplay.HasClients)
                        {
                            num7 = 0.0;
                            Thread.Sleep(10);
                        }
                    }
                }
            }
            Thread.Sleep(0);
        }
        if (Netplay.SaveOnServerExit)
        {
            Console.WriteLine(Language.GetTextValue("Net.ServerSavingOnExit"));
            WorldFile.SaveWorld();
        }
        YouCanSleepNow();
    }
 
    private static void WriteFancyWorldLoadErrorToConsole()
    {
        Console.WriteLine();
        Console.WriteLine(WorldFile.LastThrownLoadException.ToString());
    }
 
    public static void startDedInput()
    {
        Thread thread = new Thread(startDedInputCallBack);
        thread.IsBackground = true;
        thread.Name = "Server Input Thread";
        thread.Start();
    }
 
    public static void startDedInputCallBack()
    {
        while (!Netplay.Disconnect)
        {
            Console.Write(": ");
            string text = ReadLineInput();
            string text2 = text;
            text = text.ToLower();
            try
            {
                if (text == Language.GetTextValue("CLI.Help_Command"))
                {
                    Console.WriteLine(Language.GetTextValue("CLI.AvailableCommands"));
                    Console.WriteLine("");
                    List<string> list = new List<string>
                    {
                        "Help", "Playing", "Clear", "Exit", "ExitNoSave", "Save", "Kick", "Ban", "Password", "SetPassword",
                        "Version", "Time", "Port", "MaxPlayers", "Say", "MOTD", "SetMOTD", "Dawn", "Noon", "Dusk",
                        "Midnight", "Settle", "Seed"
                    };
                    int num = 0;
                    for (int i = 0; i < list.Count; i++)
                    {
                        string text3 = (Language.Exists("CLI." + list[i] + "_Example") ? Language.GetTextValue("CLI." + list[i] + "_Example") : Language.GetTextValue("CLI." + list[i] + "_Command"));
                        if (text3.Length > num)
                        {
                            num = text3.Length;
                        }
                    }
                    int num2 = (num + 1) / 8;
                    for (int j = 0; j < list.Count; j++)
                    {
                        string text4 = (Language.Exists("CLI." + list[j] + "_Example") ? Language.GetTextValue("CLI." + list[j] + "_Example") : Language.GetTextValue("CLI." + list[j] + "_Command"));
                        Console.WriteLine(text4 + new string('\t', num2 - text4.Length / 8) + Language.GetTextValue("CLI." + list[j] + "_Description"));
                    }
                }
                else if (text == Language.GetTextValue("CLI.Settle_Command"))
                {
                    if (!Liquid.panicMode)
                    {
                        Liquid.StartPanic();
                    }
                    else
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.WaterIsAlreadySettling"));
                    }
                }
                else if (text == Language.GetTextValue("CLI.Dawn_Command"))
                {
                    dayTime = true;
                    time = 0.0;
                    NetMessage.SendData(7);
                }
                else if (text == Language.GetTextValue("CLI.Dusk_Command"))
                {
                    dayTime = false;
                    time = 0.0;
                    NetMessage.SendData(7);
                }
                else if (text == Language.GetTextValue("CLI.Noon_Command"))
                {
                    dayTime = true;
                    time = 27000.0;
                    NetMessage.SendData(7);
                }
                else if (text == Language.GetTextValue("CLI.Midnight_Command"))
                {
                    dayTime = false;
                    time = 16200.0;
                    NetMessage.SendData(7);
                }
                else if (text == Language.GetTextValue("CLI.ExitNoSave_Command"))
                {
                    Netplay.SaveOnServerExit = false;
                    Netplay.Disconnect = true;
                }
                else if (text == Language.GetTextValue("CLI.Exit_Command"))
                {
                    Netplay.Disconnect = true;
                    SocialAPI.Shutdown();
                }
                else if (text == Language.GetTextValue("CLI.FPS_Command"))
                {
                    if (!dedServFPS)
                    {
                        dedServFPS = true;
                        fpsTimer.Reset();
                    }
                    else
                    {
                        dedServCount1 = 0;
                        dedServCount2 = 0;
                        dedServFPS = false;
                    }
                }
                else if (text == Language.GetTextValue("CLI.Save_Command"))
                {
                    WorldFile.SaveWorld();
                }
                else if (text == Language.GetTextValue("CLI.Time_Command"))
                {
                    string textValue = Language.GetTextValue("GameUI.TimeAtMorning");
                    double num3 = time;
                    if (!dayTime)
                    {
                        num3 += 54000.0;
                    }
                    num3 = num3 / 86400.0 * 24.0;
                    double num4 = 7.5;
                    num3 = num3 - num4 - 12.0;
                    if (num3 < 0.0)
                    {
                        num3 += 24.0;
                    }
                    if (num3 >= 12.0)
                    {
                        textValue = Language.GetTextValue("GameUI.TimePastMorning");
                    }
                    int num5 = (int)num3;
                    double num6 = (int)((num3 - (double)num5) * 60.0);
                    string text5 = string.Concat(num6);
                    if (num6 < 10.0)
                    {
                        text5 = "0" + text5;
                    }
                    if (num5 > 12)
                    {
                        num5 -= 12;
                    }
                    if (num5 == 0)
                    {
                        num5 = 12;
                    }
                    Console.WriteLine(Language.GetTextValue("CLI.Time", num5 + ":" + text5 + " " + textValue));
                }
                else if (text == Language.GetTextValue("CLI.MaxPlayers_Command"))
                {
                    Console.WriteLine(Language.GetTextValue("CLI.PlayerLimit", maxNetPlayers));
                }
                else if (text == Language.GetTextValue("CLI.Port_Command"))
                {
                    Console.WriteLine(Language.GetTextValue("CLI.Port", Netplay.ListenPort));
                }
                else if (text == Language.GetTextValue("CLI.Version_Command"))
                {
                    Console.WriteLine(Language.GetTextValue("CLI.Server", versionNumber));
                }
                else if (text == Language.GetTextValue("CLI.Clear_Command"))
                {
                    try
                    {
                        Console.Clear();
                    }
                    catch
                    {
                    }
                }
                else if (text == Language.GetTextValue("CLI.Playing_Command"))
                {
                    int num7 = 0;
                    for (int k = 0; k < 255; k++)
                    {
                        if (player[k].active)
                        {
                            num7++;
                            Console.WriteLine(string.Concat(player[k].name, " (", Netplay.Clients[k].Socket.GetRemoteAddress(), ")"));
                        }
                    }
                    switch (num7)
                    {
                    case 0:
                        Console.WriteLine(Language.GetTextValue("CLI.NoPlayers"));
                        break;
                    case 1:
                        Console.WriteLine(Language.GetTextValue("CLI.OnePlayerConnected"));
                        break;
                    default:
                        Console.WriteLine(Language.GetTextValue("CLI.PlayersConnected", num7));
                        break;
                    }
                }
                else
                {
                    if (text == "")
                    {
                        continue;
                    }
                    if (text == Language.GetTextValue("CLI.MOTD_Command"))
                    {
                        if (motd == "")
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.NoMOTD", worldName));
                        }
                        else
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.MOTD", motd));
                        }
                    }
                    else if (text.StartsWith(Language.GetTextValue("CLI.SetMOTD_Command") + " "))
                    {
                        motd = text2.Substring(Language.GetTextValue("CLI.SetMOTD_Command").Length + 1);
                    }
                    else if (text == Language.GetTextValue("CLI.Password_Command"))
                    {
                        if (Netplay.ServerPassword == "")
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.NoPassword"));
                        }
                        else
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.Password", Netplay.ServerPassword));
                        }
                    }
                    else if (text.StartsWith(Language.GetTextValue("CLI.SetPassword_Command") + " "))
                    {
                        string text6 = text2.Substring(Language.GetTextValue("CLI.SetPassword_Command").Length + 1);
                        if (text6 == "")
                        {
                            Netplay.ServerPassword = "";
                            Console.WriteLine(Language.GetTextValue("CLI.PasswordDisabled"));
                        }
                        else
                        {
                            Netplay.ServerPassword = text6;
                            Console.WriteLine(Language.GetTextValue("CLI.PasswordSet", Netplay.ServerPassword));
                        }
                    }
                    else if (text == Language.GetTextValue("CLI.Say_Command"))
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Say_Usage"));
                    }
                    else if (text.StartsWith(Language.GetTextValue("CLI.Say_Command") + " "))
                    {
                        int length = Language.GetTextValue("CLI.Say_Command").Length;
                        if (text.Length <= length + 1)
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.Say_Usage"));
                            continue;
                        }
                        string text7 = text2.Substring(length + 1);
                        Console.WriteLine(Language.GetTextValue("CLI.ServerMessage", text7));
                        ChatHelper.BroadcastChatMessage(NetworkText.FromKey("CLI.ServerMessage", text7), new Microsoft.Xna.Framework.Color(255, 240, 20));
                    }
                    else if (text == Language.GetTextValue("CLI.Kick_Command"))
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Kick_Usage"));
                    }
                    else if (text.StartsWith(Language.GetTextValue("CLI.Kick_Command") + " "))
                    {
                        int length2 = Language.GetTextValue("CLI.Kick_Command").Length;
                        if (text.Length <= length2 + 1)
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.Kick_Usage"));
                            continue;
                        }
                        string text8 = text.Substring(length2 + 1);
                        text8 = text8.ToLower();
                        for (int l = 0; l < 255; l++)
                        {
                            if (player[l].active && player[l].name.ToLower() == text8)
                            {
                                NetMessage.SendData(2, l, -1, NetworkText.FromKey("CLI.KickMessage"));
                            }
                        }
                    }
                    else if (text == Language.GetTextValue("CLI.Seed_Command"))
                    {
                        if (ActiveWorldFileData == null || !ActiveWorldFileData.HasValidSeed)
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.NoValidSeed"));
                        }
                        else
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.DisplaySeed", ActiveWorldFileData.GetFullSeedText()));
                        }
                    }
                    else if (text == Language.GetTextValue("CLI.Ban_Command"))
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.Ban_Usage"));
                    }
                    else if (text.StartsWith(Language.GetTextValue("CLI.Ban_Command") + " "))
                    {
                        int length3 = Language.GetTextValue("CLI.Ban_Command").Length;
                        if (text.Length <= length3 + 1)
                        {
                            Console.WriteLine(Language.GetTextValue("CLI.Ban_Usage"));
                            continue;
                        }
                        string text9 = text.Substring(4);
                        text9 = text9.ToLower();
                        for (int m = 0; m < 255; m++)
                        {
                            if (player[m].active && player[m].name.ToLower() == text9)
                            {
                                Netplay.AddBan(m);
                                NetMessage.SendData(2, m, -1, NetworkText.FromKey("CLI.BanMessage"));
                            }
                        }
                    }
                    else
                    {
                        Console.WriteLine(Language.GetTextValue("CLI.InvalidCommand"));
                    }
                    continue;
                }
            }
            catch
            {
                Console.WriteLine(Language.GetTextValue("CLI.InvalidCommand"));
            }
        }
    }
 
    private static string ReadLineInput()
    {
        string text = null;
        do
        {
            text = Console.ReadLine();
        }
        while (text == null);
        return text;
    }
 
    public static bool IsFastForwardingTime()
    {
        if (!fastForwardTimeToDawn)
        {
            return fastForwardTimeToDusk;
        }
        return true;
    }
 
    public static void Sundialing()
    {
        if (sundialCooldown == 0)
        {
            if (netMode == 1)
            {
                NetMessage.SendData(51, -1, -1, null, myPlayer, 3f);
                return;
            }
            fastForwardTimeToDawn = true;
            sundialCooldown = 8;
            NetMessage.SendData(7);
        }
    }
 
    public static void Moondialing()
    {
        if (moondialCooldown == 0)
        {
            if (netMode == 1)
            {
                NetMessage.SendData(51, -1, -1, null, myPlayer, 6f);
                return;
            }
            fastForwardTimeToDusk = true;
            moondialCooldown = 8;
            NetMessage.SendData(7);
        }
    }
 
    public static void UpdateTimeRate()
    {
        if (IsFastForwardingTime())
        {
            dayRate = 60;
            desiredWorldTilesUpdateRate = 1;
            return;
        }
        bool enabled = CreativePowerManager.Instance.GetPower<CreativePowers.FreezeTime>().Enabled;
        int targetTimeRate = CreativePowerManager.Instance.GetPower<CreativePowers.ModifyTimeRate>().TargetTimeRate;
        bool flag = CurrentFrameFlags.SleepingPlayersCount == CurrentFrameFlags.ActivePlayersCount && CurrentFrameFlags.SleepingPlayersCount > 0;
        int num = targetTimeRate;
        if (!gameMenu && flag)
        {
            num *= 5;
        }
        if (enabled)
        {
            num = 0;
        }
        dayRate = num;
        desiredWorldTilesUpdateRate = num;
        if (gameMenu)
        {
            dayRate = 1;
            desiredWorldTilesUpdateRate = 1;
        }
    }
 
    public Main()
    {
        instance = this;
        UnpausedUpdateSeed = (ulong)Guid.NewGuid().GetHashCode();
        base.Exiting += Main_Exiting;
        if (!dedServ)
        {
            Map = new WorldMap(maxTilesX, maxTilesY);
            Configuration.Load();
            graphics = new GraphicsDeviceManager(this as Game);
            base.Content.RootDirectory = "Content";
        }
    }
 
    private static void SetDisplayMonitor()
    {
        Configuration.Get("Display", "");
        if (Program.IsXna)
        {
            graphics.PreparingDeviceSettings += SetMonitorOnce;
        }
    }
 
    private static void SetMonitorOnce(object sender, PreparingDeviceSettingsEventArgs e)
    {
        string displayName = Configuration.Get("Display", "");
        GraphicsAdapter graphicsAdapter = GraphicsAdapter.Adapters.Where((GraphicsAdapter adapter) => adapter.DeviceName == displayName).FirstOrDefault();
        if (graphicsAdapter != null)
        {
            e.GraphicsDeviceInformation.Adapter = graphicsAdapter;
        }
        graphics.PreparingDeviceSettings -= SetMonitorOnce;
    }
 
    protected void SetTitle()
    {
        if (!dedServ)
        {
            _cachedTitle = Lang.GetRandomGameTitle();
            Platform.Get<IWindowService>().SetUnicodeTitle(base.Window, _cachedTitle);
        }
    }
 
    private static void SetTileValue()
    {
        tileOreFinderPriority[28] = 100;
        tileOreFinderPriority[407] = 150;
        tileOreFinderPriority[404] = 150;
        tileOreFinderPriority[7] = 200;
        tileOreFinderPriority[166] = 210;
        tileOreFinderPriority[6] = 220;
        tileOreFinderPriority[167] = 230;
        tileOreFinderPriority[9] = 240;
        tileOreFinderPriority[168] = 250;
        tileOreFinderPriority[8] = 260;
        tileOreFinderPriority[169] = 270;
        tileOreFinderPriority[22] = 300;
        tileOreFinderPriority[204] = 310;
        tileOreFinderPriority[37] = 400;
        tileOreFinderPriority[21] = 500;
        tileOreFinderPriority[467] = 500;
        tileOreFinderPriority[441] = 500;
        tileOreFinderPriority[468] = 500;
        tileOreFinderPriority[12] = 550;
        tileOreFinderPriority[665] = 550;
        tileOreFinderPriority[639] = 550;
        tileOreFinderPriority[107] = 600;
        tileOreFinderPriority[221] = 610;
        tileOreFinderPriority[108] = 620;
        tileOreFinderPriority[222] = 630;
        tileOreFinderPriority[111] = 640;
        tileOreFinderPriority[223] = 650;
        tileOreFinderPriority[129] = 675;
        tileOreFinderPriority[211] = 700;
        tileOreFinderPriority[227] = 750;
        tileOreFinderPriority[656] = 760;
        tileOreFinderPriority[236] = 810;
    }
 
    private static void ResetGameCounter()
    {
        _gameUpdateCount = 0u;
    }
 
    protected override void Initialize()
    {
        musicFade[50] = 1f;
        if (dedServ)
        {
            netMode = 2;
        }
        for (int i = 0; i < 10; i++)
        {
            recentWorld[i] = "";
            recentIP[i] = "";
            recentPort[i] = 0;
        }
        if (rand == null)
        {
            rand = new UnifiedRandom((int)DateTime.Now.Ticks);
        }
        SetTitle();
        lo = rand.Next(6);
        waterfallManager = new WaterfallManager();
        _windowMover = new WindowStateController();
        sittingManager = new AnchoredEntitiesCollection();
        sleepingManager = new AnchoredEntitiesCollection();
        gameTips = new GameTipsDisplay();
        if (player[myPlayer] == null)
        {
            player[myPlayer] = new Player();
        }
        ContentSamples.Initialize();
        PlayerInput.Initialize();
        player[myPlayer] = new Player();
        WorldGen.Hooks.OnWorldLoad += delegate
        {
            AmbienceServer = new AmbienceServer();
            LocalGolfState = new GolfState();
            if (!dedServ)
            {
                Lighting.Clear();
            }
        };
        DontStarveSeed.Initialize();
        ResourceSetsManager = new PlayerResourceSetsManager();
        MinimapFrameManagerInstance = new MinimapFrameManager();
        PlayerInput.OnActionableInput += delegate
        {
            if (LocalGolfState != null)
            {
                LocalGolfState.CancelBallTracking();
            }
        };
        SceneMetrics = new SceneMetrics();
        BindSettingsTo(Configuration);
        if (dedServ)
        {
            Initialize_AlmostEverything();
            return;
        }
        TimeLogger.Initialize();
        LoadContent_TryEnteringHiDef();
        ClientInitialize();
        base.Initialize();
    }
 
    private void BindSettingsTo(Preferences preferences)
    {
        waterfallManager.BindTo(preferences);
        MinimapFrameManagerInstance.BindTo(preferences);
        BigBossProgressBar.BindTo(preferences);
        ResourceSetsManager.BindTo(preferences);
        ChromaInitializer.BindTo(preferences);
        Terraria.Graphics.Effects.Filters.Scene.BindTo(preferences);
        if (SocialAPI.Cloud != null)
        {
            SocialAPI.Cloud.BindTo(preferences);
        }
        preferences.OnSave += SaveResourcePacks;
        preferences.OnLoad += LoadResourcePacks;
    }
 
    private void LoadResourcePacks(Preferences prefs)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        //IL_0011: Expected O, but got Unknown
        _lastLoadedPacks = prefs.Get<JArray>("ResourcePacks", new JArray());
    }
 
    private void SaveResourcePacks(Preferences prefs)
    {
        JArray value = _lastLoadedPacks;
        if (AssetSourceController != null)
        {
            value = AssetSourceController.ActiveResourcePackList.ToJson();
        }
        prefs.Put("ResourcePacks", value);
    }
 
    private void Initialize_AlmostEverything()
    {
        TilePaintSystem = new TilePaintSystemV2();
        TilesRenderer = new TileDrawing(TilePaintSystem);
        WallsRenderer = new WallDrawing(TilePaintSystem);
        CreativePowerManager.Initialize();
        LocalFavoriteData.Load();
        CloudFavoritesData.Load();
        Initialize_Entities();
        FindAnnouncementBoxStatus();
        CustomCurrencyManager.Initialize();
        WingStatsInitializer.Load();
        TileObjectData.Initialize();
        Animation.Initialize();
        Chest.Initialize();
        Wiring.Initialize();
        Framing.Initialize();
        ItemRarity.Initialize();
        TileEntity.InitializeAll();
        Projectile.InitializeStaticThings();
        TorchID.Initialize();
        InitializeItemAnimations();
        BestiaryDatabase bestiaryDatabase = new BestiaryDatabase();
        BestiaryDatabaseNPCsPopulator bestiaryDatabaseNPCsPopulator = new BestiaryDatabaseNPCsPopulator();
        bestiaryDatabaseNPCsPopulator.Populate(bestiaryDatabase);
        BestiaryDB = bestiaryDatabase;
        ContentSamples.RebuildBestiarySortingIDsByBestiaryDatabaseContents(bestiaryDatabase);
        BestiaryTracker = new BestiaryUnlocksTracker();
        ItemDropDatabase itemDropDatabase = new ItemDropDatabase();
        itemDropDatabase.Populate();
        ItemDropsDB = itemDropDatabase;
        bestiaryDatabase.Merge(ItemDropsDB);
        bestiaryDatabaseNPCsPopulator.AddDropOverrides(bestiaryDatabase);
        PylonSystem = new TeleportPylonsSystem();
        ItemDropSolver = new ItemDropResolver(itemDropDatabase);
        ShopHelper = new ShopHelper();
        CreativeItemSacrificesCatalog.Instance.Initialize();
        if (!dedServ)
        {
            BestiaryUI = new UIBestiaryTest(BestiaryDB);
            ContentThatNeedsRenderTargets.Add(MapPlayerRenderer);
        }
        if (!dedServ)
        {
            Lighting.Initialize();
            MapHelper.Initialize();
        }
        else
        {
            Mount.Initialize();
            Minecart.Initialize();
        }
        WorldGen.RandomizeBackgrounds(rand);
        if (treeBGSet1[0] == 173)
        {
            WorldGen.RandomizeBackgrounds(rand);
        }
        if (treeBGSet1[0] == 173)
        {
            WorldGen.RandomizeBackgrounds(rand);
        }
        WorldGen.RandomizeCaveBackgrounds();
        WorldGen.Hooks.Initialize();
        WorldGen.Hooks.OnWorldLoad += ResetGameCounter;
        bgAlphaFrontLayer[0] = 1f;
        bgAlphaFarBackLayer[0] = 1f;
        invBottom = 258;
        Initialize_TileAndNPCData1();
        Initialize_TileAndNPCData2();
        Initialize_Items();
        for (int i = 1; i < ProjectileID.Count; i++)
        {
            Projectile obj = new Projectile();
            obj.SetDefaults(i);
            if (obj.hostile)
            {
                projHostile[i] = true;
            }
            if (obj.aiStyle == 7)
            {
                projHook[i] = true;
            }
        }
        for (int j = 0; j < Recipe.maxRecipes; j++)
        {
            recipe[j] = new Recipe();
            availableRecipeY[j] = 65 * j;
        }
        Recipe.SetupRecipes();
        ContentSamples.FixItemsAfterRecipesAreAdded();
        for (int k = 0; k < Liquid.maxLiquid; k++)
        {
            liquid[k] = new Liquid();
        }
        for (int l = 0; l < 50000; l++)
        {
            liquidBuffer[l] = new LiquidBuffer();
        }
        shop[0] = new Chest();
        Chest.SetupTravelShop();
        for (int m = 1; m < 100; m++)
        {
            shop[m] = new Chest();
            shop[m].SetupShop(m);
        }
        teamColor[0] = Microsoft.Xna.Framework.Color.White;
        teamColor[1] = new Microsoft.Xna.Framework.Color(218, 59, 59);
        teamColor[2] = new Microsoft.Xna.Framework.Color(59, 218, 85);
        teamColor[3] = new Microsoft.Xna.Framework.Color(59, 149, 218);
        teamColor[4] = new Microsoft.Xna.Framework.Color(242, 221, 100);
        teamColor[5] = new Microsoft.Xna.Framework.Color(224, 100, 242);
        Netplay.Initialize();
        NetworkInitializer.Load();
        ChatInitializer.Load();
        LucyAxeMessage.Initialize();
        if (menuMode == 1)
        {
            LoadPlayers();
        }
        if (skipMenu)
        {
            WorldGen.clearWorld();
            gameMenu = false;
            LoadPlayers();
            PlayerList[0].SetAsActive();
            LoadWorlds();
            WorldGen.GenerateWorld(new UnifiedRandom().Next());
            WorldGen.EveryTileFrame();
            player[myPlayer].Spawn(PlayerSpawnContext.SpawningIntoWorld);
        }
        else if (Platform.IsWindows && !dedServ)
        {
            IntPtr systemMenu = GetSystemMenu(base.Window.Handle, bRevert: false);
            int menuItemCount = GetMenuItemCount(systemMenu);
            RemoveMenu(systemMenu, menuItemCount - 1, 1024);
        }
        if (!dedServ)
        {
            SoundID.FillAccessMap();
            Star.SpawnStars();
            ItemSorting.SetupWhiteLists();
        }
    }
 
    private void Initialize_Entities()
    {
        for (int i = 0; i < maxMenuItems; i++)
        {
            menuItemScale[i] = 0.8f;
        }
        for (int j = 0; j < 6001; j++)
        {
            dust[j] = new Dust();
            dust[j].dustIndex = j;
        }
        for (int k = 0; k < 401; k++)
        {
            item[k] = new Item();
            item[k].whoAmI = k;
        }
        for (int l = 0; l < 201; l++)
        {
            npc[l] = new NPC();
            npc[l].whoAmI = l;
        }
        for (int m = 0; m < 256; m++)
        {
            player[m] = new Player();
            player[m].whoAmI = m;
        }
        for (int n = 0; n < 1001; n++)
        {
            projectile[n] = new Projectile();
            projectile[n].whoAmI = n;
        }
        for (int num = 0; num < 601; num++)
        {
            gore[num] = new Gore();
        }
        for (int num2 = 0; num2 < maxRain + 1; num2++)
        {
            rain[num2] = new Rain();
        }
        for (int num3 = 0; num3 < 200; num3++)
        {
            cloud[num3] = new Cloud();
        }
        for (int num4 = 0; num4 < 100; num4++)
        {
            combatText[num4] = new CombatText();
        }
        for (int num5 = 0; num5 < 20; num5++)
        {
            popupText[num5] = new PopupText();
        }
    }
 
    private static void Initialize_Items()
    {
        for (int i = 0; i < ItemID.Count; i++)
        {
            Item item = new Item();
            item.SetDefaults(i);
            if (item.headSlot > 0)
            {
                Item.headType[item.headSlot] = item.type;
            }
            if (item.bodySlot > 0)
            {
                Item.bodyType[item.bodySlot] = item.type;
            }
            if (item.legSlot > 0)
            {
                Item.legType[item.legSlot] = item.type;
            }
            switch (item.type)
            {
            case 683:
            case 723:
            case 726:
            case 739:
            case 740:
            case 741:
            case 742:
            case 743:
            case 744:
            case 788:
            case 1296:
            case 1308:
            case 1326:
            case 1444:
            case 1445:
            case 1446:
            case 1801:
            case 1930:
            case 1931:
            case 2188:
            case 2750:
            case 3006:
            case 3051:
            case 3209:
            case 3210:
            case 3377:
            case 3476:
            case 3569:
            case 3571:
            case 3787:
            case 3852:
            case 3870:
            case 4062:
            case 5065:
                Item.staff[item.type] = true;
                break;
            case 1827:
                Item.claw[item.type] = true;
                break;
            }
        }
    }
 
    private static void Initialize_TileAndNPCData2()
    {
        critterCage = true;
        for (int i = 0; i < 3600; i++)
        {
            AnimateTiles_CritterCages();
        }
        critterCage = false;
        tileBlockLight[549] = true;
        tileBrick[477] = true;
        tileSolid[477] = true;
        tileBlockLight[477] = true;
        tileBrick[492] = true;
        tileSolid[492] = true;
        tileBlockLight[492] = true;
        tileSolidTop[275] = true;
        tileSolidTop[280] = true;
        tileSolidTop[276] = true;
        tileSolidTop[277] = true;
        tileSolidTop[278] = true;
        tileSolidTop[279] = true;
        tileSolidTop[281] = true;
        tileSolidTop[605] = true;
        tileSolidTop[604] = true;
        tileSolidTop[603] = true;
        tileSolidTop[602] = true;
        tileSolidTop[601] = true;
        tileSolidTop[599] = true;
        tileSolidTop[600] = true;
        tileSolidTop[612] = true;
        tileSolidTop[611] = true;
        tileSolidTop[610] = true;
        tileSolidTop[609] = true;
        tileSolidTop[608] = true;
        tileSolidTop[606] = true;
        tileSolidTop[607] = true;
        tileSolidTop[558] = true;
        tileSolidTop[554] = true;
        tileSolidTop[553] = true;
        tileSolidTop[551] = true;
        tileSolidTop[550] = true;
        tileSolidTop[542] = true;
        tileSolidTop[413] = true;
        tileSolidTop[309] = true;
        tileSolidTop[297] = true;
        tileSolidTop[296] = true;
        tileSolidTop[645] = true;
        tileSolidTop[643] = true;
        tileSolidTop[644] = true;
        tileSolidTop[632] = true;
        tileSolidTop[640] = true;
        tileSolidTop[559] = true;
        tileSolidTop[414] = true;
        tileSolidTop[359] = true;
        tileSolidTop[358] = true;
        tileSolidTop[285] = true;
        tileSolidTop[286] = true;
        tileSolidTop[582] = true;
        tileSolidTop[555] = true;
        tileSolidTop[538] = true;
        tileSolidTop[533] = true;
        tileSolidTop[532] = true;
        tileSolidTop[394] = true;
        tileSolidTop[393] = true;
        tileSolidTop[392] = true;
        tileSolidTop[391] = true;
        tileSolidTop[339] = true;
        tileSolidTop[310] = true;
        tileSolidTop[299] = true;
        tileSolidTop[298] = true;
        tileSolidTop[629] = true;
        tileSolidTop[619] = true;
        tileSolidTop[556] = true;
        tileSolidTop[544] = true;
        tileSolidTop[364] = true;
        tileSolidTop[363] = true;
        tileSolidTop[362] = true;
        tileSolidTop[361] = true;
        tileTable[280] = true;
        tileTable[275] = true;
        tileTable[276] = true;
        tileTable[277] = true;
        tileTable[278] = true;
        tileTable[279] = true;
        tileTable[281] = true;
        tileTable[605] = true;
        tileTable[604] = true;
        tileTable[603] = true;
        tileTable[602] = true;
        tileTable[601] = true;
        tileTable[599] = true;
        tileTable[600] = true;
        tileTable[612] = true;
        tileTable[611] = true;
        tileTable[610] = true;
        tileTable[609] = true;
        tileTable[608] = true;
        tileTable[606] = true;
        tileTable[607] = true;
        tileTable[558] = true;
        tileTable[554] = true;
        tileTable[553] = true;
        tileTable[551] = true;
        tileTable[550] = true;
        tileTable[542] = true;
        tileTable[413] = true;
        tileTable[309] = true;
        tileTable[297] = true;
        tileTable[296] = true;
        tileTable[645] = true;
        tileTable[643] = true;
        tileTable[644] = true;
        tileTable[632] = true;
        tileTable[640] = true;
        tileTable[559] = true;
        tileTable[414] = true;
        tileTable[359] = true;
        tileTable[358] = true;
        tileTable[285] = true;
        tileTable[286] = true;
        tileTable[582] = true;
        tileTable[555] = true;
        tileTable[538] = true;
        tileTable[533] = true;
        tileTable[532] = true;
        tileTable[394] = true;
        tileTable[393] = true;
        tileTable[392] = true;
        tileTable[391] = true;
        tileTable[339] = true;
        tileTable[310] = true;
        tileTable[299] = true;
        tileTable[298] = true;
        tileTable[629] = true;
        tileTable[619] = true;
        tileTable[556] = true;
        tileTable[544] = true;
        tileTable[364] = true;
        tileTable[363] = true;
        tileTable[362] = true;
        tileTable[361] = true;
        tileBrick[1] = true;
        tileBrick[54] = true;
        tileBrick[118] = true;
        tileBrick[119] = true;
        tileBrick[120] = true;
        tileBrick[121] = true;
        tileBrick[122] = true;
        tileBrick[140] = true;
        tileBrick[148] = true;
        tileBrick[150] = true;
        tileBrick[151] = true;
        tileBrick[152] = true;
        tileBrick[30] = true;
        tileBrick[38] = true;
        tileBrick[39] = true;
        tileBrick[41] = true;
        tileBrick[43] = true;
        tileBrick[44] = true;
        tileBrick[481] = true;
        tileBrick[482] = true;
        tileBrick[483] = true;
        tileBrick[45] = true;
        tileBrick[46] = true;
        tileBrick[47] = true;
        tileBrick[75] = true;
        tileBrick[76] = true;
        tileBrick[160] = true;
        tileBrick[2] = true;
        tileBrick[199] = true;
        tileBrick[23] = true;
        tileBrick[60] = true;
        tileBrick[70] = true;
        tileBrick[109] = true;
        tileBrick[53] = true;
        tileBrick[57] = true;
        tileBrick[116] = true;
        tileBrick[234] = true;
        tileBrick[112] = true;
        tileBrick[147] = true;
        tileBrick[153] = true;
        tileBrick[154] = true;
        tileBrick[155] = true;
        tileBrick[156] = true;
        tileBrick[157] = true;
        tileBrick[158] = true;
        tileBrick[159] = true;
        tileBrick[273] = true;
        tileBrick[274] = true;
        tileMergeDirt[202] = true;
        tileBrick[202] = true;
        tileSolid[202] = true;
        tileBlockLight[202] = true;
        tileMergeDirt[498] = true;
        tileBrick[161] = true;
        tileBlockLight[161] = true;
        tileBlockLight[163] = true;
        tileBlockLight[164] = true;
        tileSolid[188] = true;
        tileBlockLight[188] = true;
        tileBrick[188] = true;
        tileMergeDirt[188] = true;
        tileBrick[179] = true;
        tileSolid[179] = true;
        tileBlockLight[179] = true;
        tileMoss[179] = true;
        tileBrick[381] = true;
        tileSolid[381] = true;
        tileBlockLight[381] = true;
        tileMoss[381] = true;
        tileBrick[534] = true;
        tileSolid[534] = true;
        tileBlockLight[534] = true;
        tileMoss[534] = true;
        tileBrick[536] = true;
        tileSolid[536] = true;
        tileBlockLight[536] = true;
        tileMoss[536] = true;
        tileBrick[539] = true;
        tileSolid[539] = true;
        tileBlockLight[539] = true;
        tileMoss[539] = true;
        tileBrick[625] = true;
        tileSolid[625] = true;
        tileBlockLight[625] = true;
        tileMoss[625] = true;
        tileBrick[627] = true;
        tileSolid[627] = true;
        tileBlockLight[627] = true;
        tileMoss[627] = true;
        tileBrick[180] = true;
        tileSolid[180] = true;
        tileBlockLight[180] = true;
        tileMoss[180] = true;
        tileBrick[181] = true;
        tileSolid[181] = true;
        tileBlockLight[181] = true;
        tileMoss[181] = true;
        tileBrick[182] = true;
        tileSolid[182] = true;
        tileBlockLight[182] = true;
        tileMoss[182] = true;
        tileBrick[183] = true;
        tileSolid[183] = true;
        tileBlockLight[183] = true;
        tileMoss[183] = true;
        tileBrick[512] = true;
        tileSolid[512] = true;
        tileBlockLight[512] = true;
        tileBrick[513] = true;
        tileSolid[513] = true;
        tileBlockLight[513] = true;
        tileBrick[514] = true;
        tileSolid[514] = true;
        tileBlockLight[514] = true;
        tileBrick[515] = true;
        tileSolid[515] = true;
        tileBlockLight[515] = true;
        tileBrick[516] = true;
        tileSolid[516] = true;
        tileBlockLight[516] = true;
        tileBrick[517] = true;
        tileSolid[517] = true;
        tileBlockLight[517] = true;
        tileLighted[517] = true;
        tileBrick[687] = true;
        tileSolid[687] = true;
        tileBlockLight[687] = true;
        tileLighted[687] = true;
        tileBrick[535] = true;
        tileSolid[535] = true;
        tileBlockLight[535] = true;
        tileLighted[535] = true;
        tileBrick[689] = true;
        tileSolid[689] = true;
        tileBlockLight[689] = true;
        tileLighted[689] = true;
        tileBrick[537] = true;
        tileSolid[537] = true;
        tileBlockLight[537] = true;
        tileLighted[537] = true;
        tileBrick[690] = true;
        tileSolid[690] = true;
        tileBlockLight[690] = true;
        tileLighted[690] = true;
        tileBrick[540] = true;
        tileSolid[540] = true;
        tileBlockLight[540] = true;
        tileLighted[540] = true;
        tileBrick[688] = true;
        tileSolid[688] = true;
        tileBlockLight[688] = true;
        tileLighted[688] = true;
        tileBrick[626] = true;
        tileSolid[626] = true;
        tileBlockLight[626] = true;
        tileLighted[626] = true;
        tileBrick[691] = true;
        tileSolid[691] = true;
        tileBlockLight[691] = true;
        tileLighted[691] = true;
        tileBrick[628] = true;
        tileSolid[628] = true;
        tileBlockLight[628] = true;
        tileLighted[628] = true;
        tileBrick[692] = true;
        tileSolid[692] = true;
        tileBlockLight[692] = true;
        tileLighted[692] = true;
        tileLighted[592] = true;
        tileLighted[656] = true;
        tileLighted[356] = true;
        tileLighted[663] = true;
        tileMergeDirt[177] = true;
        tileMergeDirt[190] = true;
        tileSolid[196] = true;
        tileSolid[197] = true;
        tileMergeDirt[197] = true;
        tileBlockLight[197] = true;
        tileNoSunLight[197] = true;
        tileBrick[175] = true;
        tileSolid[175] = true;
        tileBlockLight[175] = true;
        tileBrick[176] = true;
        tileSolid[176] = true;
        tileBlockLight[176] = true;
        tileBrick[177] = true;
        tileSolid[177] = true;
        tileBlockLight[177] = true;
        tileBrick[225] = true;
        tileBrick[229] = true;
        tileShine[221] = 925;
        tileShine[222] = 875;
        tileShine[223] = 825;
        tileShine2[221] = true;
        tileShine2[222] = true;
        tileShine2[223] = true;
        tileMergeDirt[175] = true;
        tileMergeDirt[176] = true;
        tileMergeDirt[177] = true;
        tileMergeDirt[208] = true;
        tileBrick[162] = true;
        tileSolid[162] = true;
        tileBlockLight[162] = false;
        tileBrick[163] = true;
        tileSolid[163] = true;
        tileBrick[164] = true;
        tileSolid[164] = true;
        tileShine2[6] = true;
        tileShine2[7] = true;
        tileShine2[8] = true;
        tileShine2[9] = true;
        tileShine2[166] = true;
        tileShine2[167] = true;
        tileShine2[168] = true;
        tileShine2[169] = true;
        tileShine2[12] = true;
        tileShine2[21] = true;
        tileShine2[467] = true;
        tileShine2[441] = true;
        tileShine2[468] = true;
        tileShine2[22] = true;
        tileShine2[25] = true;
        tileShine2[45] = true;
        tileShine2[46] = true;
        tileShine2[47] = true;
        tileShine2[63] = true;
        tileShine2[64] = true;
        tileShine2[65] = true;
        tileShine2[66] = true;
        tileShine2[67] = true;
        tileShine2[68] = true;
        tileShine2[566] = true;
        tileShine2[107] = true;
        tileShine2[108] = true;
        tileShine2[111] = true;
        tileShine2[121] = true;
        tileShine2[122] = true;
        tileShine2[117] = true;
        tileShine2[211] = true;
        tileShine2[682] = true;
        tileShine2[681] = true;
        tileShine2[680] = true;
        tileShine2[685] = true;
        tileShine2[686] = true;
        tileShine[129] = 300;
        tileNoFail[81] = true;
        tileCracked[481] = true;
        tileCracked[482] = true;
        tileCracked[483] = true;
        tileNoFail[481] = true;
        tileNoFail[482] = true;
        tileNoFail[483] = true;
        tileNoFail[330] = true;
        tileNoFail[331] = true;
        tileNoFail[332] = true;
        tileNoFail[333] = true;
        tileNoFail[254] = true;
        tileNoFail[324] = true;
        tileNoFail[129] = true;
        tileNoFail[192] = true;
        tileHammer[26] = true;
        tileHammer[31] = true;
        tileAxe[5] = true;
        tileAxe[72] = true;
        tileAxe[80] = true;
        tileAxe[488] = true;
        tileAxe[323] = true;
        tileAxe[596] = true;
        tileAxe[616] = true;
        tileAxe[634] = true;
        tileAxe[589] = true;
        tileAxe[584] = true;
        tileAxe[588] = true;
        tileAxe[586] = true;
        tileAxe[587] = true;
        tileAxe[585] = true;
        tileAxe[583] = true;
        tileBrick[59] = true;
        tileBrick[234] = true;
        tileSolid[234] = true;
        tileMergeDirt[234] = true;
        tileSand[53] = true;
        tileSand[112] = true;
        tileSand[116] = true;
        tileSand[234] = true;
        tileFrameImportant[630] = true;
        tileLavaDeath[630] = true;
        tileNoSunLight[630] = true;
        tileFrameImportant[631] = true;
        tileLavaDeath[631] = true;
        tileNoSunLight[631] = true;
        tileFrameImportant[571] = true;
        tileLavaDeath[571] = true;
        tileFrameImportant[579] = true;
        tileLavaDeath[579] = true;
        tileFrameImportant[591] = true;
        tileLavaDeath[591] = true;
        tileFrameImportant[592] = true;
        tileLavaDeath[592] = false;
        tileFrameImportant[538] = true;
        tileLavaDeath[538] = true;
        tileFrameImportant[544] = true;
        tileLavaDeath[544] = true;
        tileFrameImportant[629] = true;
        tileLavaDeath[629] = true;
        tileFrameImportant[550] = true;
        tileLavaDeath[550] = true;
        tileFrameImportant[551] = true;
        tileLavaDeath[551] = true;
        tileFrameImportant[533] = true;
        tileLavaDeath[533] = true;
        tileFrameImportant[553] = true;
        tileLavaDeath[553] = true;
        tileFrameImportant[554] = true;
        tileLavaDeath[554] = true;
        tileFrameImportant[555] = true;
        tileLavaDeath[555] = true;
        tileFrameImportant[556] = true;
        tileLavaDeath[556] = true;
        tileFrameImportant[558] = true;
        tileLavaDeath[558] = true;
        tileFrameImportant[559] = true;
        tileLavaDeath[559] = true;
        tileFrameImportant[599] = true;
        tileLavaDeath[599] = true;
        tileFrameImportant[600] = true;
        tileLavaDeath[600] = true;
        tileFrameImportant[601] = true;
        tileLavaDeath[601] = true;
        tileFrameImportant[602] = true;
        tileLavaDeath[602] = true;
        tileFrameImportant[603] = true;
        tileLavaDeath[603] = true;
        tileFrameImportant[604] = true;
        tileLavaDeath[604] = true;
        tileFrameImportant[605] = true;
        tileLavaDeath[605] = true;
        tileFrameImportant[606] = true;
        tileLavaDeath[606] = true;
        tileFrameImportant[607] = true;
        tileLavaDeath[607] = true;
        tileFrameImportant[608] = true;
        tileLavaDeath[608] = true;
        tileFrameImportant[609] = true;
        tileLavaDeath[609] = true;
        tileFrameImportant[610] = true;
        tileLavaDeath[610] = true;
        tileFrameImportant[611] = true;
        tileLavaDeath[611] = true;
        tileFrameImportant[612] = true;
        tileLavaDeath[612] = true;
        tileFrameImportant[632] = true;
        tileLavaDeath[632] = true;
        tileFrameImportant[640] = true;
        tileLavaDeath[640] = true;
        tileFrameImportant[643] = true;
        tileLavaDeath[643] = true;
        tileFrameImportant[644] = true;
        tileLavaDeath[644] = true;
        tileFrameImportant[645] = true;
        tileLavaDeath[645] = true;
        tileFrameImportant[568] = true;
        tileNoAttach[568] = true;
        tileLavaDeath[568] = true;
        tileLighted[568] = true;
        tileFrameImportant[569] = true;
        tileNoAttach[569] = true;
        tileLavaDeath[569] = true;
        tileLighted[569] = true;
        tileFrameImportant[570] = true;
        tileNoAttach[570] = true;
        tileLavaDeath[570] = true;
        tileLighted[570] = true;
        tileFrameImportant[580] = true;
        tileNoAttach[580] = true;
        tileLavaDeath[580] = true;
        tileLighted[580] = true;
        tileFrameImportant[582] = true;
        tileLavaDeath[582] = true;
        tileLighted[582] = true;
        tileFrameImportant[619] = true;
        tileLavaDeath[619] = true;
        tileLighted[619] = true;
        tileFrameImportant[620] = true;
        tileNoAttach[620] = true;
        tileLavaDeath[620] = true;
        tileLighted[620] = true;
        tileFrameImportant[572] = true;
        tileNoAttach[572] = true;
        tileLavaDeath[572] = true;
        tileLighted[572] = true;
        tileFrameImportant[560] = true;
        tileLavaDeath[560] = true;
        tileFrameImportant[564] = true;
        tileNoAttach[564] = true;
        tileLavaDeath[564] = true;
        tileLighted[564] = true;
        tileFrameImportant[567] = true;
        tileLavaDeath[567] = true;
        tileFrameImportant[565] = true;
        tileNoAttach[565] = true;
        tileLavaDeath[565] = true;
        tileFrameImportant[593] = true;
        tileNoAttach[593] = true;
        tileLavaDeath[593] = false;
        tileLighted[593] = true;
        tileFrameImportant[594] = true;
        tileNoAttach[594] = true;
        tileLavaDeath[594] = false;
        tileLighted[594] = true;
        tileLighted[548] = true;
        tileLighted[613] = true;
        tileLighted[614] = true;
        tileFrameImportant[654] = true;
        tileCut[654] = true;
        tileNoFail[654] = true;
        tileLavaDeath[654] = true;
        tileFrameImportant[518] = true;
        tileCut[518] = true;
        tileNoFail[518] = true;
        tileFrameImportant[519] = true;
        tileCut[519] = true;
        tileNoFail[519] = true;
        tileLighted[519] = true;
        tileFrameImportant[549] = true;
        tileCut[549] = true;
        tileNoFail[549] = true;
        tileFrameImportant[529] = true;
        tileCut[529] = true;
        tileNoFail[529] = true;
        tileLavaDeath[529] = true;
        tileFrameImportant[637] = true;
        tileCut[637] = true;
        tileNoFail[637] = true;
        tileLavaDeath[637] = false;
        tileLighted[637] = true;
        tileFrameImportant[530] = true;
        tileNoFail[530] = true;
        tileLavaDeath[530] = true;
        tileFrameImportant[233] = true;
        tileFrameImportant[485] = true;
        tileLighted[215] = true;
        tileFrameImportant[227] = true;
        tileFrameImportant[228] = true;
        tileFrameImportant[231] = true;
        tileCut[231] = true;
        tileFrameImportant[216] = true;
        tileFrameImportant[217] = true;
        tileFrameImportant[218] = true;
        tileFrameImportant[219] = true;
        tileFrameImportant[642] = true;
        tileFrameImportant[220] = true;
        tileFrameImportant[338] = true;
        tileFrameImportant[453] = true;
        tileFrameImportant[456] = true;
        tileFrameImportant[165] = true;
        tileFrameImportant[209] = true;
        tileFrameImportant[215] = true;
        tileFrameImportant[210] = true;
        tileFrameImportant[212] = true;
        tileFrameImportant[207] = true;
        tileFrameImportant[178] = true;
        tileFrameImportant[184] = true;
        tileFrameImportant[185] = true;
        tileFrameImportant[186] = true;
        tileFrameImportant[187] = true;
        tileFrameImportant[173] = true;
        tileFrameImportant[174] = true;
        tileLighted[173] = true;
        tileLighted[174] = true;
        tileFrameImportant[139] = true;
        tileLighted[160] = true;
        tileLighted[149] = true;
        tileFrameImportant[149] = true;
        tileFrameImportant[142] = true;
        tileFrameImportant[143] = true;
        tileFrameImportant[144] = true;
        tileStone[131] = true;
        tileFrameImportant[136] = true;
        tileFrameImportant[137] = true;
        tileFrameImportant[138] = true;
        tileFrameImportant[664] = true;
        tileFrameImportant[665] = true;
        tileFrameImportant[484] = true;
        tileLavaDeath[484] = true;
        tileNoFail[484] = true;
        tileBlockLight[137] = true;
        tileSolid[137] = true;
        tileBlockLight[160] = true;
        tileSolid[160] = true;
        tileMergeDirt[160] = true;
        tileBlockLight[161] = true;
        tileSolid[161] = true;
        tileBlockLight[145] = true;
        tileSolid[145] = true;
        tileMergeDirt[145] = true;
        tileBlockLight[146] = true;
        tileSolid[146] = true;
        tileMergeDirt[146] = true;
        tileBlockLight[147] = true;
        tileSolid[147] = true;
        tileBlockLight[148] = true;
        tileSolid[148] = true;
        tileMergeDirt[148] = true;
        tileSolid[138] = true;
        tileSolid[664] = true;
        tileSolid[484] = true;
        tileCut[484] = true;
        tileBlockLight[140] = true;
        tileSolid[140] = true;
        tileBlockLight[151] = true;
        tileSolid[151] = true;
        tileMergeDirt[151] = true;
        tileBlockLight[152] = true;
        tileSolid[152] = true;
        tileMergeDirt[152] = true;
        tileBlockLight[153] = true;
        tileSolid[153] = true;
        tileMergeDirt[153] = true;
        tileBlockLight[154] = true;
        tileSolid[154] = true;
        tileMergeDirt[154] = true;
        tileBlockLight[155] = true;
        tileSolid[155] = true;
        tileMergeDirt[155] = true;
        tileBlockLight[156] = true;
        tileSolid[156] = true;
        tileMergeDirt[156] = true;
        tileMergeDirt[150] = true;
        tileBlockLight[157] = true;
        tileSolid[157] = true;
        tileMergeDirt[157] = true;
        tileBlockLight[158] = true;
        tileSolid[158] = true;
        tileMergeDirt[158] = true;
        tileBlockLight[159] = true;
        tileSolid[159] = true;
        tileMergeDirt[159] = true;
        tileFrameImportant[320] = true;
        tileFrameImportant[49] = true;
        tileShine[22] = 1150;
        tileShine[6] = 1150;
        tileShine[7] = 1100;
        tileShine[8] = 1000;
        tileShine[9] = 1050;
        tileShine[166] = 1125;
        tileShine[167] = 1075;
        tileShine[168] = 1025;
        tileShine[169] = 975;
        tileShine[617] = 400;
        tileShine[178] = 500;
        tileShine2[178] = true;
        tileShine[12] = 300;
        tileShine[21] = 1200;
        tileShine[467] = 1200;
        tileShine[441] = 1200;
        tileShine[468] = 1200;
        tileShine[63] = 900;
        tileShine[64] = 900;
        tileShine[65] = 900;
        tileShine[66] = 900;
        tileShine[67] = 900;
        tileShine[68] = 900;
        tileShine[566] = 900;
        tileShine[45] = 1900;
        tileShine[680] = 1900;
        tileShine[46] = 2000;
        tileShine[681] = 2000;
        tileShine[47] = 2100;
        tileShine[682] = 2100;
        tileShine[122] = 1800;
        tileShine[686] = 1800;
        tileShine[121] = 1850;
        tileShine[685] = 1850;
        tileShine[125] = 600;
        tileShine[109] = 9000;
        tileShine[110] = 9000;
        tileShine[116] = 9000;
        tileShine[117] = 9000;
        tileShine[118] = 8000;
        tileShine[107] = 950;
        tileShine[108] = 900;
        tileShine[111] = 850;
        tileShine[211] = 500;
        tileLighted[4] = true;
        tileLighted[17] = true;
        tileLighted[133] = true;
        tileLighted[31] = true;
        tileLighted[33] = true;
        tileLighted[34] = true;
        tileLighted[35] = true;
        tileLighted[37] = true;
        tileLighted[42] = true;
        tileLighted[49] = true;
        tileLighted[58] = true;
        tileLighted[61] = true;
        tileLighted[70] = true;
        tileLighted[71] = true;
        tileLighted[72] = true;
        tileLighted[76] = true;
        tileLighted[684] = true;
        tileLighted[77] = true;
        tileLighted[19] = true;
        tileLighted[22] = true;
        tileLighted[26] = true;
        tileLighted[83] = true;
        tileLighted[84] = true;
        tileLighted[92] = true;
        tileLighted[93] = true;
        tileLighted[95] = true;
        tileLighted[98] = true;
        tileLighted[100] = true;
        tileLighted[109] = true;
        tileLighted[125] = true;
        tileLighted[126] = true;
        tileLighted[129] = true;
        tileLighted[140] = true;
        tileLighted[270] = true;
        tileLighted[271] = true;
        tileLighted[581] = true;
        tileLighted[660] = true;
        tileLighted[578] = true;
        tileMergeDirt[1] = true;
        tileMergeDirt[6] = true;
        tileMergeDirt[7] = true;
        tileMergeDirt[8] = true;
        tileMergeDirt[9] = true;
        tileMergeDirt[166] = true;
        tileMergeDirt[167] = true;
        tileMergeDirt[168] = true;
        tileMergeDirt[169] = true;
        tileMergeDirt[22] = true;
        tileMergeDirt[25] = true;
        tileMergeDirt[30] = true;
        tileMergeDirt[37] = true;
        tileMergeDirt[38] = true;
        tileMergeDirt[40] = true;
        tileMergeDirt[53] = true;
        tileMergeDirt[56] = true;
        tileMergeDirt[107] = true;
        tileMergeDirt[108] = true;
        tileMergeDirt[111] = true;
        tileMergeDirt[112] = true;
        tileMergeDirt[116] = true;
        tileMergeDirt[117] = true;
        tileMergeDirt[123] = true;
        tileMergeDirt[140] = true;
        tileMergeDirt[39] = true;
        tileMergeDirt[122] = true;
        tileMergeDirt[121] = true;
        tileMergeDirt[120] = true;
        tileMergeDirt[119] = true;
        tileMergeDirt[118] = true;
        tileMergeDirt[47] = true;
        tileMergeDirt[46] = true;
        tileMergeDirt[45] = true;
        tileMergeDirt[41] = true;
        tileMergeDirt[43] = true;
        tileMergeDirt[44] = true;
        tileMergeDirt[481] = true;
        tileMergeDirt[482] = true;
        tileMergeDirt[483] = true;
        tileFrameImportant[380] = true;
        tileFrameImportant[201] = true;
        tileFrameImportant[3] = true;
        tileFrameImportant[4] = true;
        tileFrameImportant[5] = true;
        tileFrameImportant[10] = true;
        tileFrameImportant[11] = true;
        tileFrameImportant[12] = true;
        tileFrameImportant[13] = true;
        tileFrameImportant[14] = true;
        tileFrameImportant[469] = true;
        tileFrameImportant[486] = true;
        tileFrameImportant[488] = true;
        tileFrameImportant[487] = true;
        tileFrameImportant[489] = true;
        tileFrameImportant[490] = true;
        tileFrameImportant[15] = true;
        tileFrameImportant[497] = true;
        tileFrameImportant[16] = true;
        tileFrameImportant[17] = true;
        tileFrameImportant[18] = true;
        tileFrameImportant[19] = true;
        tileFrameImportant[20] = true;
        tileFrameImportant[21] = true;
        tileFrameImportant[467] = true;
        tileFrameImportant[441] = true;
        tileFrameImportant[468] = true;
        tileFrameImportant[24] = true;
        tileFrameImportant[26] = true;
        tileFrameImportant[27] = true;
        tileFrameImportant[28] = true;
        tileFrameImportant[29] = true;
        tileFrameImportant[31] = true;
        tileFrameImportant[33] = true;
        tileFrameImportant[34] = true;
        tileFrameImportant[35] = true;
        tileFrameImportant[42] = true;
        tileFrameImportant[50] = true;
        tileFrameImportant[55] = true;
        tileFrameImportant[61] = true;
        tileFrameImportant[71] = true;
        tileFrameImportant[72] = true;
        tileFrameImportant[73] = true;
        tileFrameImportant[74] = true;
        tileFrameImportant[77] = true;
        tileFrameImportant[78] = true;
        tileFrameImportant[79] = true;
        tileFrameImportant[81] = true;
        tileFrameImportant[82] = true;
        tileFrameImportant[83] = true;
        tileFrameImportant[84] = true;
        tileFrameImportant[85] = true;
        tileFrameImportant[86] = true;
        tileFrameImportant[87] = true;
        tileFrameImportant[88] = true;
        tileFrameImportant[89] = true;
        tileFrameImportant[90] = true;
        tileFrameImportant[91] = true;
        tileFrameImportant[92] = true;
        tileFrameImportant[93] = true;
        tileFrameImportant[94] = true;
        tileFrameImportant[95] = true;
        tileFrameImportant[96] = true;
        tileFrameImportant[97] = true;
        tileFrameImportant[98] = true;
        tileFrameImportant[99] = true;
        tileFrameImportant[101] = true;
        tileFrameImportant[102] = true;
        tileFrameImportant[103] = true;
        tileFrameImportant[104] = true;
        tileFrameImportant[105] = true;
        tileFrameImportant[100] = true;
        tileFrameImportant[106] = true;
        tileFrameImportant[110] = true;
        tileFrameImportant[113] = true;
        tileFrameImportant[114] = true;
        tileFrameImportant[125] = true;
        tileFrameImportant[287] = true;
        tileFrameImportant[126] = true;
        tileFrameImportant[128] = true;
        tileFrameImportant[129] = true;
        tileFrameImportant[132] = true;
        tileFrameImportant[133] = true;
        tileFrameImportant[134] = true;
        tileFrameImportant[135] = true;
        tileFrameImportant[172] = true;
        tileFrameImportant[319] = true;
        tileFrameImportant[323] = true;
        tileFrameImportant[335] = true;
        tileFrameImportant[337] = true;
        tileFrameImportant[349] = true;
        tileFrameImportant[376] = true;
        tileFrameImportant[378] = true;
        tileFrameImportant[425] = true;
        tileFrameImportant[465] = true;
        tileFrameImportant[506] = true;
        tileFrameImportant[510] = true;
        tileFrameImportant[511] = true;
        tileFrameImportant[531] = true;
        tileFrameImportant[545] = true;
        tileFrameImportant[547] = true;
        tileFrameImportant[548] = true;
        tileFrameImportant[552] = true;
        tileFrameImportant[573] = true;
        tileFrameImportant[613] = true;
        tileFrameImportant[614] = true;
        tileFrameImportant[621] = true;
        tileFrameImportant[622] = true;
        tileFrameImportant[623] = true;
        tileFrameImportant[624] = true;
        tileFrameImportant[656] = true;
        tileFrameImportant[141] = true;
        tileFrameImportant[270] = true;
        tileFrameImportant[271] = true;
        tileFrameImportant[581] = true;
        tileFrameImportant[660] = true;
        tileFrameImportant[314] = true;
        tileSolidTop[376] = true;
        tileTable[376] = true;
        tileTable[380] = true;
        tileFrameImportant[583] = true;
        tileFrameImportant[584] = true;
        tileFrameImportant[585] = true;
        tileFrameImportant[586] = true;
        tileFrameImportant[587] = true;
        tileFrameImportant[588] = true;
        tileFrameImportant[589] = true;
        tileFrameImportant[590] = true;
        tileNoAttach[590] = true;
        tileFrameImportant[595] = true;
        tileNoAttach[595] = true;
        tileFrameImportant[596] = true;
        tileFrameImportant[615] = true;
        tileNoAttach[615] = true;
        tileFrameImportant[616] = true;
        tileFrameImportant[634] = true;
        tileCut[201] = true;
        tileCut[3] = true;
        tileCut[24] = true;
        tileCut[28] = true;
        tileCut[32] = true;
        tileCut[51] = true;
        tileCut[52] = true;
        tileCut[61] = true;
        tileCut[62] = true;
        tileCut[69] = true;
        tileCut[655] = true;
        tileCut[71] = true;
        tileCut[73] = true;
        tileCut[74] = true;
        tileCut[82] = true;
        tileCut[83] = true;
        tileCut[84] = true;
        tileCut[110] = true;
        tileCut[113] = true;
        tileCut[115] = true;
        tileCut[184] = true;
        tileCut[205] = true;
        tileCut[352] = true;
        tileCut[382] = true;
        tileCut[528] = true;
        tileLighted[528] = true;
        tileCut[636] = true;
        tileCut[638] = true;
        tileCut[444] = true;
        tileCut[485] = true;
        tileAlch[82] = true;
        tileAlch[83] = true;
        tileAlch[84] = true;
        tileSolid[127] = true;
        tileSolid[130] = true;
        tileBlockLight[130] = true;
        tileBlockLight[131] = true;
        tileNoAttach[232] = true;
        tileSolid[107] = true;
        tileBlockLight[107] = true;
        tileSolid[108] = true;
        tileBlockLight[108] = true;
        tileSolid[111] = true;
        tileBlockLight[111] = true;
        tileSolid[109] = true;
        tileBlockLight[109] = true;
        tileSolid[110] = false;
        tileNoAttach[110] = true;
        tileNoFail[110] = true;
        tileSolid[112] = true;
        tileBlockLight[112] = true;
        tileSolid[116] = true;
        tileBlockLight[116] = true;
        tileBrick[117] = true;
        tileBrick[25] = true;
        tileBrick[203] = true;
        tileSolid[117] = true;
        tileBlockLight[117] = true;
        tileSolid[123] = true;
        tileBlockLight[123] = true;
        tileNoFail[165] = true;
        tileNoFail[184] = true;
        tileNoFail[185] = true;
        tileNoFail[186] = true;
        tileNoFail[187] = true;
        tileSolid[118] = true;
        tileBlockLight[118] = true;
        tileSolid[119] = true;
        tileBlockLight[119] = true;
        tileSolid[120] = true;
        tileBlockLight[120] = true;
        tileSolid[121] = true;
        tileBlockLight[121] = true;
        tileSolid[122] = true;
        tileBlockLight[122] = true;
        tileSolid[150] = true;
        tileBlockLight[150] = true;
        tileBlockLight[115] = true;
        tileSolid[199] = true;
        tileBlockLight[199] = true;
        tileNoFail[162] = true;
        tileSolid[0] = true;
        tileBlockLight[0] = true;
        tileSolid[1] = true;
        tileBlockLight[1] = true;
        tileSolid[2] = true;
        tileBlockLight[2] = true;
        tileSolid[3] = false;
        tileNoAttach[3] = true;
        tileNoFail[3] = true;
        tileNoFail[201] = true;
        tileSolid[4] = false;
        tileNoAttach[4] = true;
        tileNoFail[4] = true;
        tileNoFail[24] = true;
        tileSolid[5] = false;
        tileSolid[6] = true;
        tileBlockLight[6] = true;
        tileSolid[7] = true;
        tileBlockLight[7] = true;
        tileSolid[8] = true;
        tileBlockLight[8] = true;
        tileSolid[9] = true;
        tileBlockLight[9] = true;
        tileSolid[166] = true;
        tileBlockLight[166] = true;
        tileSolid[167] = true;
        tileBlockLight[167] = true;
        tileSolid[168] = true;
        tileBlockLight[168] = true;
        tileSolid[169] = true;
        tileBlockLight[169] = true;
        tileBlockLight[10] = true;
        tileSolid[10] = true;
        tileNoAttach[10] = true;
        tileBlockLight[10] = true;
        tileSolid[11] = false;
        tileSolidTop[19] = true;
        tileSolid[19] = true;
        tileSolid[22] = true;
        tileSolid[23] = true;
        tileSolid[25] = true;
        tileSolid[30] = true;
        tileNoFail[32] = true;
        tileBlockLight[32] = true;
        tileNoFail[352] = true;
        tileBlockLight[352] = true;
        tileSolid[37] = true;
        tileBlockLight[37] = true;
        tileSolid[38] = true;
        tileBlockLight[38] = true;
        tileSolid[39] = true;
        tileBlockLight[39] = true;
        tileSolid[40] = true;
        tileBlockLight[40] = true;
        tileSolid[41] = true;
        tileBlockLight[41] = true;
        tileSolid[43] = true;
        tileBlockLight[43] = true;
        tileSolid[44] = true;
        tileBlockLight[44] = true;
        tileSolid[481] = true;
        tileBlockLight[481] = true;
        tileSolid[482] = true;
        tileBlockLight[482] = true;
        tileSolid[483] = true;
        tileBlockLight[483] = true;
        tileSolid[634] = false;
        tileFrameImportant[634] = true;
        tileLavaDeath[634] = false;
        tileBlockLight[634] = false;
        tileLighted[634] = true;
        tileLighted[20] = true;
        tileSolid[45] = true;
        tileBlockLight[45] = true;
        tileSolid[46] = true;
        tileBlockLight[46] = true;
        tileSolid[47] = true;
        tileBlockLight[47] = true;
        tileSolid[48] = true;
        tileSolid[53] = true;
        tileBlockLight[53] = true;
        tileSolid[54] = true;
        tileBlockLight[52] = true;
        tileBlockLight[205] = true;
        tileSolid[56] = true;
        tileBlockLight[56] = true;
        tileSolid[57] = true;
        tileBlockLight[57] = true;
        tileSolid[58] = true;
        tileBlockLight[58] = true;
        tileBlockLight[382] = true;
        tileSolid[59] = true;
        tileBlockLight[59] = true;
        tileSolid[60] = true;
        tileBlockLight[60] = true;
        tileSolid[63] = true;
        tileBlockLight[63] = true;
        tileStone[63] = true;
        tileStone[130] = true;
        tileSolid[64] = true;
        tileBlockLight[64] = true;
        tileStone[64] = true;
        tileSolid[65] = true;
        tileBlockLight[65] = true;
        tileStone[65] = true;
        tileSolid[66] = true;
        tileBlockLight[66] = true;
        tileStone[66] = true;
        tileSolid[67] = true;
        tileBlockLight[67] = true;
        tileStone[67] = true;
        tileSolid[68] = true;
        tileBlockLight[68] = true;
        tileStone[68] = true;
        tileSolid[566] = true;
        tileBlockLight[566] = true;
        tileStone[566] = true;
        tileSolid[75] = true;
        tileBlockLight[75] = true;
        tileBrick[633] = true;
        tileSolid[633] = true;
        tileBlockLight[633] = true;
        tileLighted[633] = true;
        tileSolid[76] = true;
        tileBlockLight[76] = true;
        tileSolid[70] = true;
        tileBlockLight[70] = true;
        tileSolid[661] = true;
        tileBlockLight[661] = true;
        tileBrick[661] = true;
        tileSolid[662] = true;
        tileBlockLight[662] = true;
        tileBrick[662] = true;
        tileNoFail[50] = true;
        tileNoAttach[50] = true;
        tileDungeon[41] = true;
        tileDungeon[43] = true;
        tileDungeon[44] = true;
        tileBlockLight[30] = true;
        tileBlockLight[25] = true;
        tileBlockLight[23] = true;
        tileBlockLight[22] = true;
        tileBlockLight[62] = true;
        tileSolidTop[18] = true;
        tileSolidTop[14] = true;
        tileSolidTop[469] = true;
        tileSolidTop[16] = true;
        tileSolidTop[134] = true;
        tileSolidTop[114] = true;
        tileNoAttach[20] = true;
        tileNoAttach[19] = true;
        tileNoAttach[13] = true;
        tileNoAttach[14] = true;
        tileNoAttach[469] = true;
        tileNoAttach[486] = true;
        tileNoAttach[488] = true;
        tileNoAttach[487] = true;
        tileNoAttach[489] = true;
        tileNoAttach[490] = true;
        tileNoAttach[15] = true;
        tileNoAttach[497] = true;
        tileNoAttach[16] = true;
        tileNoAttach[134] = true;
        tileNoAttach[17] = true;
        tileNoAttach[18] = true;
        tileNoAttach[21] = true;
        tileNoAttach[467] = true;
        tileNoAttach[441] = true;
        tileNoAttach[468] = true;
        tileNoAttach[27] = true;
        tileNoAttach[114] = true;
        tileTable[14] = true;
        tileTable[469] = true;
        tileTable[18] = true;
        tileTable[19] = true;
        tileTable[114] = true;
        tileNoAttach[86] = true;
        tileNoAttach[87] = true;
        tileNoAttach[88] = true;
        tileNoAttach[89] = true;
        tileNoAttach[90] = true;
        tileTable[101] = true;
        tileNoAttach[101] = true;
        tileNoAttach[102] = true;
        tileNoAttach[94] = true;
        tileNoAttach[95] = true;
        tileNoAttach[96] = true;
        tileNoAttach[97] = true;
        tileNoAttach[98] = true;
        tileNoAttach[99] = true;
        tileTable[87] = true;
        tileTable[88] = true;
        tileSolidTop[87] = true;
        tileSolidTop[88] = true;
        tileSolidTop[101] = true;
        tileNoAttach[91] = true;
        tileNoAttach[92] = true;
        tileNoAttach[93] = true;
        tileLighted[190] = true;
        tileBlockLight[192] = true;
        tileWaterDeath[215] = true;
        tileWaterDeath[4] = true;
        tileWaterDeath[51] = true;
        tileWaterDeath[93] = true;
        tileWaterDeath[98] = true;
        tileWaterDeath[552] = true;
        tileLavaDeath[3] = true;
        tileLavaDeath[5] = true;
        tileLavaDeath[10] = true;
        tileLavaDeath[11] = true;
        tileLavaDeath[12] = true;
        tileLavaDeath[13] = true;
        tileLavaDeath[14] = true;
        tileLavaDeath[469] = true;
        tileLavaDeath[486] = true;
        tileLavaDeath[488] = true;
        tileLavaDeath[487] = true;
        tileLavaDeath[489] = true;
        tileLavaDeath[490] = true;
        tileLavaDeath[15] = true;
        tileLavaDeath[497] = true;
        tileLavaDeath[16] = true;
        tileLavaDeath[17] = true;
        tileLavaDeath[18] = true;
        tileLavaDeath[19] = true;
        tileLavaDeath[24] = true;
        tileLavaDeath[27] = true;
        tileLavaDeath[28] = true;
        tileLavaDeath[29] = true;
        tileLavaDeath[32] = true;
        tileLavaDeath[33] = true;
        tileLavaDeath[34] = true;
        tileLavaDeath[35] = true;
        tileLavaDeath[36] = true;
        tileLavaDeath[42] = true;
        tileLavaDeath[49] = true;
        tileLavaDeath[50] = true;
        tileLavaDeath[51] = true;
        tileLavaDeath[52] = true;
        tileLavaDeath[55] = true;
        tileLavaDeath[61] = true;
        tileLavaDeath[62] = true;
        tileLavaDeath[69] = true;
        tileLavaDeath[655] = true;
        tileLavaDeath[71] = true;
        tileLavaDeath[72] = true;
        tileLavaDeath[73] = true;
        tileLavaDeath[74] = true;
        tileLavaDeath[79] = true;
        tileLavaDeath[80] = true;
        tileLavaDeath[81] = true;
        tileLavaDeath[86] = true;
        tileLavaDeath[87] = true;
        tileLavaDeath[88] = true;
        tileLavaDeath[89] = true;
        tileLavaDeath[90] = true;
        tileLavaDeath[91] = true;
        tileLavaDeath[92] = true;
        tileLavaDeath[93] = true;
        tileLavaDeath[94] = true;
        tileLavaDeath[95] = true;
        tileLavaDeath[96] = true;
        tileLavaDeath[97] = true;
        tileLavaDeath[98] = true;
        tileLavaDeath[100] = true;
        tileLavaDeath[101] = true;
        tileLavaDeath[102] = true;
        tileLavaDeath[103] = true;
        tileLavaDeath[104] = true;
        tileLavaDeath[106] = true;
        tileLavaDeath[110] = true;
        tileLavaDeath[113] = true;
        tileLavaDeath[115] = true;
        tileLavaDeath[125] = true;
        tileLavaDeath[126] = true;
        tileLavaDeath[128] = true;
        tileLavaDeath[149] = true;
        tileLavaDeath[172] = true;
        tileLavaDeath[173] = true;
        tileLavaDeath[174] = true;
        tileLavaDeath[184] = true;
        tileLavaDeath[201] = true;
        tileLavaDeath[205] = true;
        tileLavaDeath[201] = true;
        tileLavaDeath[209] = true;
        tileLavaDeath[210] = true;
        tileLavaDeath[212] = true;
        tileLavaDeath[213] = true;
        tileLavaDeath[353] = true;
        tileLavaDeath[214] = false;
        tileLavaDeath[215] = true;
        tileLavaDeath[216] = true;
        tileLavaDeath[217] = true;
        tileLavaDeath[218] = true;
        tileLavaDeath[219] = true;
        tileLavaDeath[642] = true;
        tileLavaDeath[220] = true;
        tileLavaDeath[227] = true;
        tileLavaDeath[228] = true;
        tileLavaDeath[233] = true;
        tileLavaDeath[236] = true;
        tileLavaDeath[238] = true;
        tileLavaDeath[240] = true;
        tileLavaDeath[241] = true;
        tileLavaDeath[242] = true;
        tileLavaDeath[243] = true;
        tileLavaDeath[244] = true;
        tileLavaDeath[245] = true;
        tileLavaDeath[246] = true;
        tileLavaDeath[247] = true;
        tileLavaDeath[254] = true;
        tileLavaDeath[269] = true;
        tileLavaDeath[270] = true;
        tileLavaDeath[271] = true;
        tileLavaDeath[581] = true;
        tileLavaDeath[660] = true;
        tileLavaDeath[275] = true;
        tileLavaDeath[413] = true;
        tileLavaDeath[276] = true;
        tileLavaDeath[277] = true;
        tileLavaDeath[278] = true;
        tileLavaDeath[279] = true;
        tileLavaDeath[280] = true;
        tileLavaDeath[281] = true;
        tileLavaDeath[282] = true;
        tileLavaDeath[283] = true;
        tileLavaDeath[285] = true;
        tileLavaDeath[286] = true;
        tileLavaDeath[287] = true;
        tileLavaDeath[288] = true;
        tileLavaDeath[289] = true;
        tileLavaDeath[290] = true;
        tileLavaDeath[291] = true;
        tileLavaDeath[292] = true;
        tileLavaDeath[293] = true;
        tileLavaDeath[294] = true;
        tileLavaDeath[295] = true;
        tileLavaDeath[296] = true;
        tileLavaDeath[297] = true;
        tileLavaDeath[298] = true;
        tileLavaDeath[299] = true;
        tileLavaDeath[300] = true;
        tileLavaDeath[301] = true;
        tileLavaDeath[302] = true;
        tileLavaDeath[303] = true;
        tileLavaDeath[304] = true;
        tileLavaDeath[305] = true;
        tileLavaDeath[306] = true;
        tileLavaDeath[307] = true;
        tileLavaDeath[308] = true;
        tileLavaDeath[309] = true;
        tileLavaDeath[310] = true;
        tileLavaDeath[532] = true;
        tileLavaDeath[316] = true;
        tileLavaDeath[317] = true;
        tileLavaDeath[318] = true;
        tileLavaDeath[319] = true;
        tileLavaDeath[354] = true;
        tileLavaDeath[355] = true;
        tileLavaDeath[499] = true;
        tileLavaDeath[323] = true;
        tileLavaDeath[335] = true;
        tileLavaDeath[338] = true;
        tileLavaDeath[339] = true;
        tileLavaDeath[528] = true;
        tileLavaDeath[636] = true;
        tileLavaDeath[638] = false;
        tileLavaDeath[352] = true;
        tileLavaDeath[382] = true;
        tileLavaDeath[425] = true;
        tileLavaDeath[453] = true;
        tileLavaDeath[456] = true;
        tileLavaDeath[463] = true;
        tileLavaDeath[464] = true;
        tileLavaDeath[465] = true;
        tileLavaDeath[485] = true;
        tileLavaDeath[511] = true;
        tileLavaDeath[510] = true;
        tileLavaDeath[547] = true;
        tileLavaDeath[548] = true;
        tileLavaDeath[552] = true;
        tileLavaDeath[573] = true;
        tileLavaDeath[621] = true;
        tileLavaDeath[622] = true;
        tileLavaDeath[623] = true;
        tileLavaDeath[624] = true;
        tileLavaDeath[656] = true;
        tileLighted[316] = true;
        tileLighted[317] = true;
        tileLighted[318] = true;
        tileFrameImportant[493] = true;
        tileLavaDeath[493] = true;
        for (int j = 0; j < TileID.Count; j++)
        {
            if (tileLavaDeath[j])
            {
                tileObsidianKill[j] = true;
            }
        }
        tileObsidianKill[546] = true;
        tileObsidianKill[77] = true;
        tileObsidianKill[78] = true;
        tileObsidianKill[82] = true;
        tileObsidianKill[83] = true;
        tileObsidianKill[84] = true;
        tileObsidianKill[85] = true;
        tileObsidianKill[105] = true;
        tileObsidianKill[129] = true;
        tileObsidianKill[132] = true;
        tileObsidianKill[133] = true;
        tileObsidianKill[134] = true;
        tileObsidianKill[135] = true;
        tileObsidianKill[136] = true;
        tileObsidianKill[139] = true;
        tileObsidianKill[165] = true;
        tileObsidianKill[178] = true;
        tileObsidianKill[185] = true;
        tileObsidianKill[186] = true;
        tileObsidianKill[187] = true;
        tileObsidianKill[231] = true;
        tileObsidianKill[337] = true;
        tileObsidianKill[349] = true;
        tileObsidianKill[506] = true;
        tileObsidianKill[314] = true;
        tileSolid[384] = true;
        tileBlockLight[384] = true;
        tileNoFail[384] = true;
        tileFrameImportant[395] = true;
        tileLavaDeath[395] = true;
        tileFrameImportant[520] = true;
        tileLavaDeath[520] = true;
        tileLavaDeath[471] = true;
        tileFrameImportant[405] = true;
        tileLavaDeath[405] = true;
        tileSolidTop[405] = true;
        tileTable[405] = true;
        tileLighted[405] = true;
        tileWaterDeath[405] = true;
        tileFrameImportant[406] = true;
        tileLavaDeath[406] = true;
        tileFrameImportant[452] = true;
        tileLavaDeath[452] = true;
        tileFrameImportant[411] = true;
        tileLavaDeath[411] = false;
        tileFrameImportant[457] = true;
        tileLavaDeath[457] = true;
        tileFrameImportant[462] = true;
        tileFrameImportant[454] = true;
        tileLavaDeath[454] = true;
        tileCut[454] = true;
        tileFrameImportant[494] = true;
        tileLavaDeath[494] = true;
        tileFrameImportant[455] = true;
        tileFrameImportant[412] = true;
        for (int k = 0; k < WallID.Count; k++)
        {
            int num = WallID.Sets.BlendType[k];
            if (num >= 0 && num < WallID.Count)
            {
                wallBlend[k] = num;
            }
            else
            {
                wallBlend[k] = k;
            }
        }
        tileNoFail[24] = true;
        tileNoFail[3] = true;
        tileNoFail[52] = true;
        tileNoFail[62] = true;
        tileNoFail[32] = true;
        tileNoFail[61] = true;
        tileNoFail[69] = true;
        tileNoFail[655] = true;
        tileNoFail[73] = true;
        tileNoFail[74] = true;
        tileNoFail[82] = true;
        tileNoFail[83] = true;
        tileNoFail[84] = true;
        tileNoFail[110] = true;
        tileNoFail[113] = true;
        tileNoFail[115] = true;
        tileNoFail[165] = true;
        tileNoFail[184] = true;
        tileNoFail[201] = true;
        tileNoFail[205] = true;
        tileNoFail[227] = true;
        tileNoFail[233] = true;
        tileNoFail[624] = true;
        tileNoFail[352] = true;
        tileNoFail[382] = true;
        tileNoFail[528] = true;
        tileNoFail[485] = true;
        tileNoFail[636] = true;
        tileNoFail[638] = true;
        tileNoFail[656] = true;
        tileLighted[638] = true;
        tileFrameImportant[387] = true;
        tileSolid[387] = true;
        tileBlockLight[387] = true;
        tileNoAttach[387] = true;
        tileLavaDeath[387] = true;
        tileFrameImportant[386] = true;
        tileLavaDeath[386] = true;
        tileNoSunLight[386] = true;
        tileFrameImportant[388] = true;
        tileSolid[388] = true;
        tileBlockLight[388] = true;
        tileNoAttach[388] = true;
        tileLavaDeath[388] = true;
        tileFrameImportant[389] = true;
        tileLavaDeath[389] = true;
        tileNoSunLight[389] = true;
        for (int l = 0; l < TileID.Count; l++)
        {
            if (tileSolid[l])
            {
                tileNoSunLight[l] = true;
            }
            tileFrame[l] = 0;
            tileFrameCounter[l] = 0;
        }
        tileNoSunLight[546] = false;
        tileNoSunLight[379] = false;
        tileNoSunLight[54] = false;
        tileNoSunLight[328] = false;
        tileNoSunLight[459] = false;
        tileNoSunLight[19] = false;
        tileNoSunLight[11] = true;
        tileNoSunLight[189] = false;
        tileNoSunLight[196] = false;
        tileNoSunLight[48] = false;
        tileNoSunLight[232] = false;
        tileNoSunLight[460] = false;
        tileNoSunLight[541] = false;
        tileNoSunLight[388] = false;
        AddEchoFurnitureTile(647);
        AddEchoFurnitureTile(648);
        AddEchoFurnitureTile(650);
        AddEchoFurnitureTile(649);
        AddEchoFurnitureTile(652);
        AddEchoFurnitureTile(651);
        tileFrameImportant[653] = true;
    }
 
    private static void AddEchoFurnitureTile(int tileId)
    {
        tileFrameImportant[tileId] = true;
        tileNoFail[tileId] = true;
        tileObsidianKill[tileId] = true;
    }
 
    private static void Initialize_TileAndNPCData1()
    {
        for (int i = 0; i < TileID.Count; i++)
        {
            tileGlowMask[i] = -1;
        }
        for (int j = 0; j < ProjectileID.Count; j++)
        {
            projFrames[j] = 1;
        }
        projFrames[736] = 3;
        projFrames[737] = 3;
        projFrames[738] = 3;
        projFrames[779] = 4;
        projFrames[783] = 4;
        projFrames[862] = 4;
        projFrames[863] = 4;
        projFrames[820] = 4;
        projFrames[916] = 6;
        projFrames[34] = 6;
        projFrames[706] = 8;
        projFrames[712] = 8;
        projFrames[663] = 7;
        projFrames[665] = 9;
        projFrames[667] = 9;
        projFrames[677] = 6;
        projFrames[678] = 6;
        projFrames[679] = 6;
        projFrames[688] = 6;
        projFrames[689] = 6;
        projFrames[690] = 8;
        projFrames[691] = 4;
        projFrames[692] = 4;
        projFrames[693] = 4;
        projFrames[694] = 4;
        projFrames[695] = 4;
        projFrames[696] = 5;
        projFrames[700] = 4;
        projFrames[964] = 1;
        projFrames[965] = 1;
        projFrames[643] = 8;
        projFrames[566] = 4;
        projFrames[565] = 4;
        projFrames[525] = 5;
        projFrames[519] = 4;
        projFrames[509] = 2;
        projFrames[485] = 5;
        projFrames[492] = 8;
        projFrames[500] = 4;
        projFrames[499] = 12;
        projFrames[518] = 4;
        projFrames[585] = 4;
        projFrames[593] = 4;
        projFrames[595] = 28;
        projFrames[735] = 28;
        projFrames[596] = 4;
        projFrames[612] = 5;
        projFrames[978] = 5;
        projFrames[613] = 4;
        projFrames[614] = 4;
        projFrames[615] = 7;
        projFrames[623] = 19;
        projFrames[633] = 5;
        projFrames[645] = 7;
        projFrames[650] = 4;
        projFrames[652] = 6;
        projFrames[659] = 4;
        projFrames[714] = 7;
        projFrames[734] = 8;
        projFrames[755] = 5;
        projFrames[759] = 5;
        projFrames[765] = 10;
        projFrames[951] = 12;
        projFrames[953] = 5;
        projFrames[384] = 6;
        projFrames[385] = 3;
        projFrames[386] = 6;
        projFrames[390] = 11;
        projFrames[391] = 11;
        projFrames[392] = 11;
        projFrames[393] = 15;
        projFrames[394] = 15;
        projFrames[395] = 15;
        projFrames[398] = 10;
        projFrames[407] = 6;
        projFrames[408] = 2;
        projFrames[409] = 3;
        projFrames[387] = 3;
        projFrames[388] = 3;
        projFrames[334] = 11;
        projFrames[324] = 10;
        projFrames[351] = 2;
        projFrames[349] = 5;
        projFrames[423] = 4;
        projFrames[435] = 4;
        projFrames[682] = 4;
        projFrames[436] = 4;
        projFrames[439] = 6;
        projFrames[443] = 4;
        projFrames[447] = 4;
        projFrames[448] = 3;
        projFrames[450] = 5;
        projFrames[454] = 2;
        projFrames[456] = 4;
        projFrames[459] = 3;
        projFrames[462] = 5;
        projFrames[465] = 4;
        projFrames[467] = 4;
        projFrames[468] = 4;
        projFrames[533] = 21;
        projFrames[535] = 12;
        projFrames[539] = 4;
        projFrames[575] = 4;
        projFrames[574] = 2;
        projFrames[634] = 4;
        projFrames[635] = 4;
        projFrames[709] = 3;
        projFrames[353] = 14;
        projFrames[346] = 2;
        projFrames[347] = 2;
        projFrames[335] = 4;
        projFrames[344] = 3;
        projFrames[337] = 5;
        projFrames[317] = 8;
        projFrames[321] = 3;
        projFrames[308] = 10;
        projFrames[316] = 4;
        projFrames[275] = 2;
        projFrames[276] = 2;
        projFrames[254] = 5;
        projFrames[307] = 2;
        projFrames[72] = 4;
        projFrames[86] = 4;
        projFrames[87] = 4;
        projFrames[102] = 2;
        projFrames[111] = 8;
        projFrames[112] = 6;
        projFrames[127] = 16;
        projFrames[175] = 2;
        projFrames[181] = 4;
        projFrames[189] = 4;
        projFrames[191] = 18;
        projFrames[192] = 18;
        projFrames[193] = 18;
        projFrames[194] = 18;
        projFrames[190] = 4;
        projFrames[198] = 4;
        projFrames[199] = 8;
        projFrames[200] = 10;
        projFrames[206] = 5;
        projFrames[208] = 5;
        projFrames[209] = 12;
        projFrames[210] = 12;
        projFrames[211] = 10;
        projFrames[221] = 3;
        projFrames[237] = 4;
        projFrames[238] = 6;
        projFrames[221] = 3;
        projFrames[228] = 5;
        projFrames[229] = 4;
        projFrames[236] = 13;
        projFrames[243] = 4;
        projFrames[244] = 6;
        projFrames[249] = 5;
        projFrames[252] = 4;
        projFrames[266] = 6;
        projFrames[268] = 8;
        projFrames[269] = 7;
        projFrames[270] = 3;
        projFrames[313] = 12;
        projFrames[314] = 13;
        projFrames[319] = 11;
        projFrames[373] = 3;
        projFrames[375] = 8;
        projFrames[377] = 9;
        projFrames[379] = 4;
        projFrames[380] = 4;
        projFrames[601] = 2;
        projFrames[602] = 4;
        projFrames[703] = 8;
        projFrames[701] = 3;
        projFrames[702] = 4;
        projFrames[732] = 4;
        projFrames[731] = 4;
        projFrames[758] = 24;
        projFrames[766] = 4;
        projFrames[767] = 4;
        projFrames[768] = 4;
        projFrames[769] = 4;
        projFrames[770] = 4;
        projFrames[774] = 8;
        projFrames[773] = 4;
        projFrames[815] = 10;
        projFrames[816] = 17;
        projFrames[817] = 18;
        projFrames[821] = 23;
        projFrames[824] = 4;
        projFrames[825] = 26;
        projFrames[826] = 3;
        projFrames[828] = 2;
        projFrames[829] = 2;
        projFrames[831] = 6;
        projFrames[970] = 6;
        projFrames[833] = 10;
        projFrames[834] = 12;
        projFrames[835] = 12;
        projFrames[836] = 4;
        projFrames[837] = 3;
        projFrames[839] = 4;
        projFrames[840] = 4;
        projFrames[851] = 4;
        projFrames[853] = 4;
        projFrames[854] = 19;
        projFrames[855] = 4;
        projFrames[858] = 14;
        projFrames[859] = 24;
        projFrames[860] = 14;
        projFrames[861] = 4;
        projFrames[864] = 2;
        projFrames[866] = 4;
        projFrames[870] = 4;
        projFrames[875] = 11;
        projFrames[881] = 12;
        projFrames[882] = 20;
        projFrames[883] = 3;
        projFrames[884] = 14;
        projFrames[885] = 10;
        projFrames[886] = 8;
        projFrames[887] = 3;
        projFrames[888] = 36;
        projFrames[889] = 11;
        projFrames[890] = 12;
        projFrames[891] = 15;
        projFrames[892] = 6;
        projFrames[893] = 4;
        projFrames[894] = 8;
        projFrames[895] = 6;
        projFrames[896] = 16;
        projFrames[897] = 11;
        projFrames[898] = 16;
        projFrames[899] = 14;
        projFrames[900] = 14;
        projFrames[901] = 12;
        projFrames[908] = 12;
        projFrames[909] = 6;
        projFrames[920] = 3;
        projFrames[934] = 12;
        projFrames[880] = 8;
        projFrames[929] = 8;
        projFrames[956] = 11;
        projFrames[957] = 12;
        projFrames[958] = 17;
        projFrames[959] = 12;
        projFrames[960] = 20;
        projFrames[961] = 1;
        projFrames[962] = 3;
        projFrames[963] = 13;
        projFrames[966] = 3;
        projFrames[967] = 8;
        projFrames[968] = 24;
        projFrames[969] = 8;
        projFrames[994] = 16;
        projFrames[995] = 20;
        projFrames[998] = 10;
        projFrames[1003] = 16;
        projFrames[1004] = 15;
        projFrames[1014] = 11;
        projPet[492] = true;
        projPet[499] = true;
        projPet[653] = true;
        projPet[701] = true;
        projPet[703] = true;
        projPet[702] = true;
        projPet[764] = true;
        projPet[765] = true;
        projPet[319] = true;
        projPet[334] = true;
        projPet[324] = true;
        projPet[266] = true;
        projPet[313] = true;
        projPet[314] = true;
        projPet[317] = true;
        projPet[175] = true;
        projPet[111] = true;
        projPet[112] = true;
        projPet[127] = true;
        projPet[191] = true;
        projPet[192] = true;
        projPet[193] = true;
        projPet[194] = true;
        projPet[197] = true;
        projPet[198] = true;
        projPet[199] = true;
        projPet[200] = true;
        projPet[208] = true;
        projPet[209] = true;
        projPet[210] = true;
        projPet[211] = true;
        projPet[236] = true;
        projPet[268] = true;
        projPet[269] = true;
        projPet[353] = true;
        projPet[373] = true;
        projPet[375] = true;
        projPet[380] = true;
        projPet[387] = true;
        projPet[388] = true;
        projPet[390] = true;
        projPet[391] = true;
        projPet[392] = true;
        projPet[393] = true;
        projPet[394] = true;
        projPet[395] = true;
        projPet[398] = true;
        projPet[407] = true;
        projPet[423] = true;
        projPet[533] = true;
        projPet[613] = true;
        projPet[623] = true;
        projPet[625] = true;
        projPet[626] = true;
        projPet[627] = true;
        projPet[628] = true;
        projPet[755] = true;
        projPet[758] = true;
        projPet[759] = true;
        projPet[774] = true;
        projPet[815] = true;
        projPet[816] = true;
        projPet[817] = true;
        projPet[821] = true;
        projPet[825] = true;
        projPet[831] = true;
        projPet[833] = true;
        projPet[834] = true;
        projPet[835] = true;
        projPet[854] = true;
        projPet[858] = true;
        projPet[859] = true;
        projPet[860] = true;
        projPet[864] = true;
        projPet[875] = true;
        projPet[946] = true;
        projPet[951] = true;
        projPet[963] = true;
        projPet[970] = true;
        projPet[881] = true;
        projPet[882] = true;
        projPet[883] = true;
        projPet[884] = true;
        projPet[885] = true;
        projPet[886] = true;
        projPet[887] = true;
        projPet[888] = true;
        projPet[889] = true;
        projPet[890] = true;
        projPet[891] = true;
        projPet[892] = true;
        projPet[893] = true;
        projPet[894] = true;
        projPet[895] = true;
        projPet[896] = true;
        projPet[897] = true;
        projPet[898] = true;
        projPet[899] = true;
        projPet[900] = true;
        projPet[901] = true;
        projPet[934] = true;
        projPet[956] = true;
        projPet[957] = true;
        projPet[958] = true;
        projPet[959] = true;
        projPet[960] = true;
        projPet[994] = true;
        projPet[998] = true;
        projPet[1003] = true;
        projPet[1004] = true;
        projPet[1018] = true;
        tileLighted[237] = true;
        tileLighted[27] = true;
        tileLighted[381] = true;
        tileLighted[534] = true;
        tileLighted[536] = true;
        tileLighted[539] = true;
        tileLighted[625] = true;
        tileLighted[627] = true;
        tileLighted[184] = true;
        tileLighted[463] = true;
        tileLighted[491] = true;
        slimeRainNPC[1] = true;
        debuff[158] = true;
        debuff[160] = true;
        debuff[20] = true;
        debuff[21] = true;
        debuff[22] = true;
        debuff[23] = true;
        debuff[24] = true;
        debuff[25] = true;
        debuff[28] = true;
        debuff[30] = true;
        debuff[31] = true;
        debuff[32] = true;
        debuff[33] = true;
        debuff[34] = true;
        debuff[35] = true;
        debuff[36] = true;
        debuff[37] = true;
        debuff[38] = true;
        debuff[39] = true;
        debuff[44] = true;
        debuff[46] = true;
        debuff[47] = true;
        debuff[67] = true;
        debuff[68] = true;
        debuff[69] = true;
        debuff[70] = true;
        debuff[80] = true;
        debuff[86] = true;
        debuff[87] = true;
        debuff[88] = true;
        debuff[89] = true;
        debuff[94] = true;
        debuff[103] = true;
        debuff[119] = true;
        debuff[120] = true;
        debuff[137] = true;
        debuff[145] = true;
        debuff[146] = true;
        debuff[147] = true;
        debuff[148] = true;
        debuff[149] = true;
        debuff[156] = true;
        debuff[157] = true;
        debuff[350] = true;
        debuff[163] = true;
        debuff[164] = true;
        debuff[144] = true;
        debuff[194] = true;
        debuff[195] = true;
        debuff[196] = true;
        debuff[197] = true;
        debuff[199] = true;
        debuff[215] = true;
        debuff[320] = true;
        debuff[321] = true;
        debuff[332] = true;
        debuff[333] = true;
        debuff[334] = true;
        debuff[353] = true;
        pvpBuff[20] = true;
        pvpBuff[70] = true;
        pvpBuff[24] = true;
        pvpBuff[323] = true;
        pvpBuff[31] = true;
        pvpBuff[39] = true;
        pvpBuff[44] = true;
        pvpBuff[324] = true;
        pvpBuff[69] = true;
        pvpBuff[103] = true;
        pvpBuff[119] = true;
        pvpBuff[120] = true;
        pvpBuff[137] = true;
        pvpBuff[320] = true;
        meleeBuff[71] = true;
        meleeBuff[73] = true;
        meleeBuff[74] = true;
        meleeBuff[75] = true;
        meleeBuff[76] = true;
        meleeBuff[77] = true;
        meleeBuff[78] = true;
        meleeBuff[79] = true;
        buffNoSave[20] = true;
        buffNoSave[22] = true;
        buffNoSave[23] = true;
        buffNoSave[24] = true;
        buffNoSave[28] = true;
        buffNoSave[30] = true;
        buffNoSave[31] = true;
        buffNoSave[34] = true;
        buffNoSave[35] = true;
        buffNoSave[37] = true;
        buffNoSave[38] = true;
        buffNoSave[39] = true;
        buffNoSave[43] = true;
        buffNoSave[44] = true;
        buffNoSave[46] = true;
        buffNoSave[47] = true;
        buffNoSave[48] = true;
        buffNoSave[58] = true;
        buffNoSave[59] = true;
        buffNoSave[60] = true;
        buffNoSave[62] = true;
        buffNoSave[63] = true;
        buffNoSave[64] = true;
        buffNoSave[67] = true;
        buffNoSave[68] = true;
        buffNoSave[69] = true;
        buffNoSave[70] = true;
        buffNoSave[72] = true;
        buffNoSave[80] = true;
        buffNoSave[87] = true;
        buffNoSave[158] = true;
        buffNoSave[146] = true;
        buffNoSave[147] = true;
        buffNoSave[215] = true;
        buffNoSave[88] = true;
        buffNoSave[89] = true;
        buffNoSave[94] = true;
        buffNoSave[95] = true;
        buffNoSave[96] = true;
        buffNoSave[97] = true;
        buffNoSave[98] = true;
        buffNoSave[99] = true;
        buffNoSave[100] = true;
        buffNoSave[103] = true;
        buffNoSave[118] = true;
        buffNoSave[138] = true;
        buffNoSave[167] = true;
        buffNoSave[166] = true;
        buffNoSave[184] = true;
        buffNoSave[185] = true;
        buffNoSave[211] = true;
        buffNoSave[210] = true;
        buffNoSave[119] = true;
        buffNoSave[120] = true;
        buffNoSave[90] = true;
        buffNoSave[125] = true;
        buffNoSave[126] = true;
        buffNoSave[128] = true;
        buffNoSave[129] = true;
        buffNoSave[130] = true;
        buffNoSave[131] = true;
        buffNoSave[132] = true;
        buffNoSave[133] = true;
        buffNoSave[134] = true;
        buffNoSave[135] = true;
        buffNoSave[139] = true;
        buffNoSave[140] = true;
        buffNoSave[141] = true;
        buffNoSave[142] = true;
        buffNoSave[143] = true;
        buffNoSave[137] = true;
        buffNoSave[144] = true;
        buffNoSave[161] = true;
        buffNoSave[162] = true;
        buffNoSave[163] = true;
        buffNoSave[164] = true;
        buffNoSave[168] = true;
        buffNoSave[170] = true;
        buffNoSave[171] = true;
        buffNoSave[172] = true;
        buffNoSave[182] = true;
        buffNoSave[187] = true;
        buffNoSave[188] = true;
        buffNoSave[193] = true;
        buffNoSave[194] = true;
        buffNoSave[195] = true;
        buffNoSave[196] = true;
        buffNoSave[197] = true;
        buffNoSave[198] = true;
        buffNoSave[199] = true;
        buffNoSave[205] = true;
        buffNoSave[212] = true;
        buffNoSave[213] = true;
        buffNoSave[214] = true;
        buffNoSave[230] = true;
        buffNoSave[263] = true;
        buffNoSave[265] = true;
        buffNoSave[271] = true;
        buffNoSave[322] = true;
        buffNoSave[275] = true;
        buffNoSave[276] = true;
        buffNoSave[277] = true;
        buffNoSave[278] = true;
        buffNoSave[279] = true;
        buffNoSave[280] = true;
        buffNoSave[281] = true;
        buffNoSave[282] = true;
        buffNoSave[283] = true;
        buffNoSave[305] = true;
        buffNoSave[318] = true;
        buffNoSave[342] = true;
        buffNoSave[320] = true;
        buffNoSave[321] = true;
        buffNoSave[325] = true;
        buffNoSave[335] = true;
        buffNoSave[150] = true;
        buffNoSave[93] = true;
        buffNoSave[159] = true;
        buffNoSave[29] = true;
        buffNoSave[348] = true;
        buffNoSave[353] = true;
        for (int k = 173; k <= 181; k++)
        {
            buffNoSave[k] = true;
        }
        buffNoTimeDisplay[19] = true;
        buffNoTimeDisplay[27] = true;
        buffNoTimeDisplay[28] = true;
        buffNoTimeDisplay[34] = true;
        buffNoTimeDisplay[37] = true;
        buffNoTimeDisplay[38] = true;
        buffNoTimeDisplay[40] = true;
        buffNoTimeDisplay[41] = true;
        buffNoTimeDisplay[42] = true;
        buffNoTimeDisplay[43] = true;
        buffNoTimeDisplay[45] = true;
        buffNoTimeDisplay[49] = true;
        buffNoTimeDisplay[60] = true;
        buffNoTimeDisplay[62] = true;
        buffNoTimeDisplay[64] = true;
        buffNoTimeDisplay[68] = true;
        buffNoTimeDisplay[81] = true;
        buffNoTimeDisplay[82] = true;
        buffNoTimeDisplay[83] = true;
        buffNoTimeDisplay[90] = true;
        buffNoTimeDisplay[95] = true;
        buffNoTimeDisplay[96] = true;
        buffNoTimeDisplay[97] = true;
        buffNoTimeDisplay[98] = true;
        buffNoTimeDisplay[99] = true;
        buffNoTimeDisplay[100] = true;
        buffNoTimeDisplay[101] = true;
        buffNoTimeDisplay[102] = true;
        buffNoTimeDisplay[118] = true;
        buffNoTimeDisplay[138] = true;
        buffNoTimeDisplay[167] = true;
        buffNoTimeDisplay[166] = true;
        buffNoTimeDisplay[184] = true;
        buffNoTimeDisplay[185] = true;
        buffNoTimeDisplay[211] = true;
        buffNoTimeDisplay[210] = true;
        buffNoTimeDisplay[125] = true;
        buffNoTimeDisplay[126] = true;
        buffNoTimeDisplay[128] = true;
        buffNoTimeDisplay[129] = true;
        buffNoTimeDisplay[130] = true;
        buffNoTimeDisplay[131] = true;
        buffNoTimeDisplay[132] = true;
        buffNoTimeDisplay[133] = true;
        buffNoTimeDisplay[134] = true;
        buffNoTimeDisplay[135] = true;
        buffNoTimeDisplay[136] = true;
        buffNoTimeDisplay[139] = true;
        buffNoTimeDisplay[140] = true;
        buffNoTimeDisplay[141] = true;
        buffNoTimeDisplay[142] = true;
        buffNoTimeDisplay[143] = true;
        buffNoTimeDisplay[137] = true;
        buffNoTimeDisplay[200] = true;
        buffNoTimeDisplay[202] = true;
        buffNoTimeDisplay[201] = true;
        buffNoTimeDisplay[161] = true;
        buffNoTimeDisplay[162] = true;
        buffNoTimeDisplay[163] = true;
        buffNoTimeDisplay[168] = true;
        buffNoTimeDisplay[170] = true;
        buffNoTimeDisplay[171] = true;
        buffNoTimeDisplay[172] = true;
        buffNoTimeDisplay[182] = true;
        buffNoTimeDisplay[165] = true;
        buffNoTimeDisplay[186] = true;
        buffNoTimeDisplay[187] = true;
        buffNoTimeDisplay[188] = true;
        buffNoTimeDisplay[193] = true;
        buffNoTimeDisplay[199] = true;
        buffNoTimeDisplay[212] = true;
        buffNoTimeDisplay[213] = true;
        buffNoTimeDisplay[214] = true;
        buffNoTimeDisplay[216] = true;
        buffNoTimeDisplay[217] = true;
        buffNoTimeDisplay[219] = true;
        buffNoTimeDisplay[230] = true;
        buffNoTimeDisplay[258] = true;
        buffNoTimeDisplay[259] = true;
        buffNoTimeDisplay[260] = true;
        buffNoTimeDisplay[261] = true;
        buffNoTimeDisplay[262] = true;
        buffNoTimeDisplay[263] = true;
        buffNoTimeDisplay[264] = true;
        buffNoTimeDisplay[265] = true;
        buffNoTimeDisplay[266] = true;
        buffNoTimeDisplay[267] = true;
        buffNoTimeDisplay[268] = true;
        buffNoTimeDisplay[271] = true;
        buffNoTimeDisplay[322] = true;
        buffNoTimeDisplay[274] = true;
        buffNoTimeDisplay[275] = true;
        buffNoTimeDisplay[276] = true;
        buffNoTimeDisplay[277] = true;
        buffNoTimeDisplay[278] = true;
        buffNoTimeDisplay[279] = true;
        buffNoTimeDisplay[280] = true;
        buffNoTimeDisplay[281] = true;
        buffNoTimeDisplay[282] = true;
        buffNoTimeDisplay[283] = true;
        buffNoTimeDisplay[284] = true;
        buffNoTimeDisplay[285] = true;
        buffNoTimeDisplay[286] = true;
        buffNoTimeDisplay[287] = true;
        buffNoTimeDisplay[288] = true;
        buffNoTimeDisplay[289] = true;
        buffNoTimeDisplay[290] = true;
        buffNoTimeDisplay[291] = true;
        buffNoTimeDisplay[292] = true;
        buffNoTimeDisplay[293] = true;
        buffNoTimeDisplay[294] = true;
        buffNoTimeDisplay[295] = true;
        buffNoTimeDisplay[296] = true;
        buffNoTimeDisplay[297] = true;
        buffNoTimeDisplay[298] = true;
        buffNoTimeDisplay[299] = true;
        buffNoTimeDisplay[300] = true;
        buffNoTimeDisplay[301] = true;
        buffNoTimeDisplay[302] = true;
        buffNoTimeDisplay[303] = true;
        buffNoTimeDisplay[304] = true;
        buffNoTimeDisplay[305] = true;
        buffNoTimeDisplay[317] = true;
        buffNoTimeDisplay[318] = true;
        buffNoTimeDisplay[342] = true;
        buffNoTimeDisplay[320] = true;
        buffNoTimeDisplay[325] = true;
        buffNoTimeDisplay[335] = true;
        buffNoTimeDisplay[341] = true;
        buffNoTimeDisplay[327] = true;
        buffNoTimeDisplay[328] = true;
        buffNoTimeDisplay[329] = true;
        buffNoTimeDisplay[330] = true;
        buffNoTimeDisplay[331] = true;
        buffNoTimeDisplay[334] = true;
        buffNoTimeDisplay[345] = true;
        buffNoTimeDisplay[349] = true;
        buffNoTimeDisplay[351] = true;
        buffNoTimeDisplay[352] = true;
        buffNoTimeDisplay[354] = true;
        buffNoTimeDisplay[29] = true;
        buffNoTimeDisplay[159] = true;
        buffNoTimeDisplay[150] = true;
        buffNoTimeDisplay[93] = true;
        buffNoTimeDisplay[348] = true;
        buffNoTimeDisplay[353] = true;
        persistentBuff[71] = true;
        persistentBuff[73] = true;
        persistentBuff[74] = true;
        persistentBuff[75] = true;
        persistentBuff[76] = true;
        persistentBuff[77] = true;
        persistentBuff[78] = true;
        persistentBuff[79] = true;
        for (int l = 0; l < BuffID.Sets.BasicMountData.Length; l++)
        {
            if (BuffID.Sets.BasicMountData[l] != null)
            {
                buffNoTimeDisplay[l] = true;
                buffNoSave[l] = true;
            }
        }
        vanityPet[40] = true;
        vanityPet[41] = true;
        vanityPet[42] = true;
        vanityPet[45] = true;
        vanityPet[50] = true;
        vanityPet[51] = true;
        vanityPet[52] = true;
        vanityPet[53] = true;
        vanityPet[54] = true;
        vanityPet[55] = true;
        vanityPet[56] = true;
        vanityPet[61] = true;
        vanityPet[154] = true;
        vanityPet[65] = true;
        vanityPet[66] = true;
        vanityPet[81] = true;
        vanityPet[82] = true;
        vanityPet[84] = true;
        vanityPet[85] = true;
        vanityPet[91] = true;
        vanityPet[92] = true;
        vanityPet[127] = true;
        vanityPet[136] = true;
        vanityPet[191] = true;
        vanityPet[202] = true;
        vanityPet[200] = true;
        vanityPet[218] = true;
        vanityPet[219] = true;
        vanityPet[217] = true;
        vanityPet[258] = true;
        vanityPet[259] = true;
        vanityPet[260] = true;
        vanityPet[261] = true;
        vanityPet[262] = true;
        vanityPet[264] = true;
        vanityPet[266] = true;
        vanityPet[267] = true;
        vanityPet[268] = true;
        vanityPet[274] = true;
        vanityPet[284] = true;
        vanityPet[285] = true;
        vanityPet[286] = true;
        vanityPet[287] = true;
        vanityPet[288] = true;
        vanityPet[289] = true;
        vanityPet[290] = true;
        vanityPet[291] = true;
        vanityPet[292] = true;
        vanityPet[293] = true;
        vanityPet[295] = true;
        vanityPet[296] = true;
        vanityPet[297] = true;
        vanityPet[300] = true;
        vanityPet[301] = true;
        vanityPet[302] = true;
        vanityPet[303] = true;
        vanityPet[304] = true;
        vanityPet[317] = true;
        vanityPet[341] = true;
        vanityPet[327] = true;
        vanityPet[328] = true;
        vanityPet[329] = true;
        vanityPet[330] = true;
        vanityPet[331] = true;
        vanityPet[345] = true;
        vanityPet[349] = true;
        vanityPet[351] = true;
        vanityPet[352] = true;
        vanityPet[354] = true;
        lightPet[19] = true;
        lightPet[155] = true;
        lightPet[27] = true;
        lightPet[101] = true;
        lightPet[102] = true;
        lightPet[57] = true;
        lightPet[190] = true;
        lightPet[152] = true;
        lightPet[201] = true;
        lightPet[294] = true;
        lightPet[298] = true;
        lightPet[299] = true;
        tileFlame[4] = true;
        tileFlame[33] = true;
        tileFlame[34] = true;
        tileFlame[35] = true;
        tileFlame[42] = true;
        tileFlame[49] = true;
        tileFlame[93] = true;
        tileFlame[98] = true;
        tileFlame[100] = true;
        tileFlame[173] = true;
        tileFlame[174] = true;
        tileFlame[372] = true;
        tileFlame[646] = true;
        tileRope[213] = true;
        tileRope[214] = true;
        tileRope[353] = true;
        tileRope[365] = true;
        tileRope[366] = true;
        tileRope[504] = true;
        tileRope[449] = true;
        tileRope[450] = true;
        tileRope[451] = true;
        tilePile[330] = true;
        tilePile[331] = true;
        tilePile[332] = true;
        tilePile[333] = true;
        for (int m = 0; m < NPCID.Count; m++)
        {
            npcCatchable[m] = false;
        }
        npcCatchable[46] = true;
        npcCatchable[55] = true;
        npcCatchable[74] = true;
        npcCatchable[148] = true;
        npcCatchable[149] = true;
        npcCatchable[297] = true;
        npcCatchable[298] = true;
        npcCatchable[299] = true;
        npcCatchable[300] = true;
        npcCatchable[355] = true;
        npcCatchable[356] = true;
        npcCatchable[357] = true;
        npcCatchable[358] = true;
        npcCatchable[359] = true;
        npcCatchable[360] = true;
        npcCatchable[361] = true;
        npcCatchable[362] = true;
        npcCatchable[363] = true;
        npcCatchable[364] = true;
        npcCatchable[365] = true;
        npcCatchable[366] = true;
        npcCatchable[367] = true;
        npcCatchable[374] = true;
        npcCatchable[377] = true;
        npcCatchable[539] = true;
        npcCatchable[538] = true;
        npcCatchable[671] = true;
        npcCatchable[672] = true;
        npcCatchable[673] = true;
        npcCatchable[674] = true;
        npcCatchable[675] = true;
        npcCatchable[484] = true;
        npcCatchable[485] = true;
        npcCatchable[486] = true;
        npcCatchable[487] = true;
        npcCatchable[583] = true;
        npcCatchable[584] = true;
        npcCatchable[585] = true;
        npcCatchable[592] = true;
        npcCatchable[593] = true;
        npcCatchable[595] = true;
        npcCatchable[596] = true;
        npcCatchable[597] = true;
        npcCatchable[598] = true;
        npcCatchable[599] = true;
        npcCatchable[600] = true;
        npcCatchable[601] = true;
        npcCatchable[604] = true;
        npcCatchable[605] = true;
        npcCatchable[602] = true;
        npcCatchable[603] = true;
        npcCatchable[606] = true;
        npcCatchable[607] = true;
        npcCatchable[608] = true;
        npcCatchable[609] = true;
        npcCatchable[610] = true;
        npcCatchable[611] = true;
        npcCatchable[612] = true;
        npcCatchable[613] = true;
        npcCatchable[614] = true;
        npcCatchable[616] = true;
        npcCatchable[617] = true;
        npcCatchable[626] = true;
        npcCatchable[627] = true;
        npcCatchable[639] = true;
        npcCatchable[640] = true;
        npcCatchable[641] = true;
        npcCatchable[642] = true;
        npcCatchable[643] = true;
        npcCatchable[644] = true;
        npcCatchable[645] = true;
        npcCatchable[646] = true;
        npcCatchable[647] = true;
        npcCatchable[648] = true;
        npcCatchable[649] = true;
        npcCatchable[650] = true;
        npcCatchable[651] = true;
        npcCatchable[652] = true;
        npcCatchable[653] = true;
        npcCatchable[654] = true;
        npcCatchable[655] = true;
        npcCatchable[661] = true;
        npcCatchable[669] = true;
        npcCatchable[677] = true;
        for (int n = 442; n <= 448; n++)
        {
            npcCatchable[n] = true;
        }
        SetTileValue();
        tileSpelunker[6] = true;
        tileSpelunker[7] = true;
        tileSpelunker[8] = true;
        tileSpelunker[9] = true;
        tileSpelunker[12] = true;
        tileSpelunker[21] = true;
        tileSpelunker[467] = true;
        tileSpelunker[441] = true;
        tileSpelunker[468] = true;
        tileSpelunker[28] = true;
        tileSpelunker[107] = true;
        tileSpelunker[108] = true;
        tileSpelunker[111] = true;
        tileSpelunker[63] = true;
        tileSpelunker[64] = true;
        tileSpelunker[65] = true;
        tileSpelunker[66] = true;
        tileSpelunker[67] = true;
        tileSpelunker[68] = true;
        tileSpelunker[566] = true;
        tileSpelunker[166] = true;
        tileSpelunker[167] = true;
        tileSpelunker[168] = true;
        tileSpelunker[169] = true;
        tileSpelunker[178] = true;
        tileSpelunker[211] = true;
        tileSpelunker[221] = true;
        tileSpelunker[222] = true;
        tileSpelunker[223] = true;
        tileSpelunker[236] = true;
        tileSpelunker[37] = true;
        tileSpelunker[407] = true;
        tileSpelunker[227] = true;
        tileSpelunker[84] = true;
        tileSpelunker[83] = true;
        tileSpelunker[404] = true;
        tileSpelunker[242] = true;
        tileSpelunker[240] = true;
        tileSpelunker[246] = true;
        tileSpelunker[245] = true;
        tileSpelunker[105] = true;
        tileSpelunker[349] = true;
        tileSpelunker[337] = true;
        tileSpelunker[531] = true;
        tileSpelunker[506] = true;
        tileSolid[379] = true;
        tileMergeDirt[249] = true;
        tileBrick[268] = true;
        tileBrick[262] = true;
        tileBrick[267] = true;
        tileBrick[265] = true;
        tileBrick[266] = true;
        tileBrick[264] = true;
        tileBrick[263] = true;
        tileBrick[261] = true;
        tileBrick[255] = true;
        tileBrick[260] = true;
        tileBrick[258] = true;
        tileBrick[259] = true;
        tileBrick[257] = true;
        tileBrick[256] = true;
        tileSolid[371] = true;
        tileMergeDirt[371] = true;
        tileBlockLight[371] = true;
        tileBouncy[371] = true;
        tileBouncy[448] = true;
        tileBouncy[446] = true;
        tileBouncy[447] = true;
        tileFrameImportant[377] = true;
        tileFrameImportant[373] = true;
        tileFrameImportant[375] = true;
        tileFrameImportant[374] = true;
        tileFrameImportant[461] = true;
        tileLighted[646] = true;
        tileFrameImportant[646] = true;
        tileWaterDeath[646] = true;
        tileLavaDeath[646] = true;
        tileLighted[372] = true;
        tileFrameImportant[372] = true;
        tileWaterDeath[372] = true;
        tileLavaDeath[372] = true;
        tileSolid[357] = true;
        tileBrick[357] = true;
        tileBrick[311] = true;
        tileSolid[408] = true;
        tileMergeDirt[408] = true;
        tileBrick[408] = true;
        tileBlockLight[408] = true;
        tileSolid[409] = true;
        tileBrick[409] = true;
        tileBlockLight[409] = true;
        tileSolid[669] = true;
        tileBrick[669] = true;
        tileBlockLight[669] = true;
        tileSolid[670] = true;
        tileBrick[670] = true;
        tileBlockLight[670] = true;
        tileSolid[671] = true;
        tileBrick[671] = true;
        tileBlockLight[671] = true;
        tileSolid[672] = true;
        tileBrick[672] = true;
        tileBlockLight[672] = true;
        tileSolid[673] = true;
        tileBrick[673] = true;
        tileBlockLight[673] = true;
        tileSolid[674] = true;
        tileBrick[674] = true;
        tileBlockLight[674] = true;
        tileSolid[675] = true;
        tileBrick[675] = true;
        tileBlockLight[675] = true;
        tileSolid[676] = true;
        tileBrick[676] = true;
        tileBlockLight[676] = true;
        tileSolid[677] = true;
        tileBrick[677] = true;
        tileBlockLight[677] = true;
        tileMergeDirt[677] = true;
        tileSolid[678] = true;
        tileBrick[678] = true;
        tileBlockLight[678] = true;
        tileMergeDirt[678] = true;
        tileSolid[679] = true;
        tileBrick[679] = true;
        tileBlockLight[679] = true;
        tileMergeDirt[679] = true;
        tileSolid[680] = true;
        tileBrick[680] = true;
        tileBlockLight[680] = true;
        tileMergeDirt[680] = true;
        tileSolid[681] = true;
        tileBrick[681] = true;
        tileBlockLight[681] = true;
        tileMergeDirt[681] = true;
        tileSolid[682] = true;
        tileBrick[682] = true;
        tileBlockLight[682] = true;
        tileMergeDirt[682] = true;
        tileSolid[683] = true;
        tileBrick[683] = true;
        tileBlockLight[683] = true;
        tileMergeDirt[683] = true;
        tileSolid[684] = true;
        tileBrick[684] = true;
        tileBlockLight[684] = true;
        tileMergeDirt[684] = true;
        tileSolid[685] = true;
        tileBrick[685] = true;
        tileBlockLight[685] = true;
        tileMergeDirt[685] = true;
        tileSolid[686] = true;
        tileBrick[686] = true;
        tileBlockLight[686] = true;
        tileMergeDirt[686] = true;
        tileSolid[666] = true;
        tileBlockLight[666] = true;
        tileBrick[666] = true;
        tileMergeDirt[666] = true;
        tileNoFail[666] = true;
        tileSolid[415] = true;
        tileBrick[415] = true;
        tileLighted[415] = true;
        tileBlockLight[415] = true;
        tileSolid[416] = true;
        tileBrick[416] = true;
        tileLighted[416] = true;
        tileBlockLight[416] = true;
        tileSolid[417] = true;
        tileBrick[417] = true;
        tileLighted[417] = true;
        tileBlockLight[417] = true;
        tileSolid[418] = true;
        tileBrick[418] = true;
        tileLighted[418] = true;
        tileBlockLight[418] = true;
        tileSolid[498] = true;
        tileBrick[498] = true;
        tileBlockLight[498] = true;
        tileBrick[37] = true;
        tileBrick[117] = true;
        tileBrick[25] = true;
        tileBrick[203] = true;
        tileSolid[232] = true;
        tileSolid[311] = true;
        tileBlockLight[311] = true;
        tileSolid[312] = true;
        tileBlockLight[313] = true;
        tileSolid[313] = true;
        tileBlockLight[312] = true;
        tileMergeDirt[311] = true;
        tileSolid[315] = true;
        tileBlockLight[315] = true;
        tileMergeDirt[315] = true;
        tileBrick[315] = true;
        tileSolid[641] = true;
        tileBlockLight[641] = true;
        tileMergeDirt[641] = true;
        tileBrick[641] = true;
        tileSolid[659] = true;
        tileBlockLight[659] = true;
        tileLighted[659] = true;
        tileBrick[659] = true;
        tileSolid[667] = true;
        tileBlockLight[667] = true;
        tileBrick[667] = true;
        tileLighted[667] = true;
        tileSolid[321] = true;
        tileSolid[322] = true;
        tileBlockLight[321] = true;
        tileBlockLight[322] = true;
        tileMergeDirt[321] = true;
        tileMergeDirt[322] = true;
        tileBrick[321] = true;
        tileBrick[322] = true;
        tileSolid[635] = true;
        tileBlockLight[635] = true;
        tileMergeDirt[635] = true;
        tileBrick[635] = true;
        tileFrameImportant[639] = true;
        tileLavaDeath[639] = true;
        tileSpelunker[639] = true;
        tileShine[639] = 300;
        tileShine2[639] = true;
        tileLavaDeath[668] = true;
        tileSolid[668] = true;
        tileBlockLight[668] = true;
        tileShine[239] = 1100;
        tileSolid[239] = true;
        tileSolidTop[239] = true;
        tileSolid[380] = true;
        tileSolidTop[380] = true;
        tileFrameImportant[358] = true;
        tileFrameImportant[359] = true;
        tileFrameImportant[360] = true;
        tileFrameImportant[361] = true;
        tileFrameImportant[362] = true;
        tileFrameImportant[363] = true;
        tileFrameImportant[364] = true;
        tileFrameImportant[391] = true;
        tileLighted[391] = true;
        tileFrameImportant[392] = true;
        tileFrameImportant[393] = true;
        tileFrameImportant[394] = true;
        tileFrameImportant[542] = true;
        tileFrameImportant[505] = true;
        tileFrameImportant[521] = true;
        tileFrameImportant[522] = true;
        tileFrameImportant[523] = true;
        tileFrameImportant[524] = true;
        tileFrameImportant[525] = true;
        tileFrameImportant[526] = true;
        tileFrameImportant[527] = true;
        tileFrameImportant[543] = true;
        tileFrameImportant[568] = true;
        tileFrameImportant[569] = true;
        tileFrameImportant[570] = true;
        tileFrameImportant[598] = true;
        tileFrameImportant[356] = true;
        tileFrameImportant[663] = true;
        tileFrameImportant[334] = true;
        tileFrameImportant[440] = true;
        tileFrameImportant[471] = true;
        tileFrameImportant[300] = true;
        tileFrameImportant[301] = true;
        tileFrameImportant[302] = true;
        tileFrameImportant[303] = true;
        tileFrameImportant[304] = true;
        tileFrameImportant[305] = true;
        tileFrameImportant[306] = true;
        tileFrameImportant[307] = true;
        tileFrameImportant[308] = true;
        tileFrameImportant[354] = true;
        tileLighted[354] = true;
        tileFrameImportant[499] = true;
        tileFrameImportant[355] = true;
        tileFrameImportant[324] = true;
        tileObsidianKill[324] = true;
        tileLavaDeath[324] = true;
        tileFrameImportant[463] = true;
        tileFrameImportant[491] = true;
        tileFrameImportant[464] = true;
        tileFrameImportant[466] = true;
        tileFrameImportant[419] = true;
        tileFrameImportant[442] = true;
        tileFrameImportant[443] = true;
        tileFrameImportant[444] = true;
        tileFrameImportant[420] = true;
        tileFrameImportant[423] = true;
        tileFrameImportant[424] = true;
        tileFrameImportant[428] = true;
        tileFrameImportant[520] = true;
        tileFrameImportant[429] = true;
        tileFrameImportant[445] = true;
        tileFrameImportant[476] = true;
        tileFrameImportant[283] = true;
        tileFrameImportant[288] = true;
        tileFrameImportant[289] = true;
        tileFrameImportant[290] = true;
        tileFrameImportant[291] = true;
        tileFrameImportant[292] = true;
        tileFrameImportant[293] = true;
        tileFrameImportant[294] = true;
        tileFrameImportant[295] = true;
        tileFrameImportant[296] = true;
        tileFrameImportant[297] = true;
        tileFrameImportant[316] = true;
        tileFrameImportant[317] = true;
        tileFrameImportant[318] = true;
        tileLargeFrames[284] = 1;
        wallHouse[224] = true;
        wallLargeFrames[224] = 2;
        wallHouse[323] = true;
        wallLargeFrames[323] = 2;
        wallHouse[324] = true;
        wallLargeFrames[324] = 2;
        wallHouse[325] = true;
        wallLargeFrames[325] = 2;
        wallHouse[326] = true;
        wallLargeFrames[326] = 2;
        wallHouse[327] = true;
        wallLargeFrames[327] = 2;
        wallHouse[328] = true;
        wallLargeFrames[328] = 2;
        wallHouse[329] = true;
        wallLargeFrames[329] = 2;
        wallHouse[330] = true;
        wallLargeFrames[330] = 2;
        wallHouse[331] = true;
        wallHouse[332] = true;
        wallHouse[333] = true;
        wallHouse[334] = true;
        wallHouse[335] = true;
        wallHouse[336] = true;
        wallHouse[337] = true;
        wallHouse[338] = true;
        wallHouse[339] = true;
        wallHouse[340] = true;
        wallHouse[341] = true;
        wallHouse[342] = true;
        wallHouse[343] = true;
        wallHouse[344] = true;
        wallHouse[345] = true;
        wallHouse[346] = true;
        wallHouse[60] = true;
        wallHouse[225] = true;
        wallHouse[226] = true;
        wallHouse[227] = true;
        wallHouse[231] = true;
        wallHouse[232] = true;
        wallHouse[233] = true;
        wallHouse[235] = true;
        wallHouse[234] = true;
        wallHouse[312] = true;
        wallHouse[313] = true;
        wallHouse[237] = true;
        wallHouse[238] = true;
        wallHouse[239] = true;
        wallHouse[240] = true;
        tileLargeFrames[409] = 2;
        tileLargeFrames[669] = 2;
        tileLargeFrames[670] = 2;
        tileLargeFrames[671] = 2;
        tileLargeFrames[672] = 2;
        tileLargeFrames[673] = 2;
        tileLargeFrames[674] = 2;
        tileLargeFrames[675] = 2;
        tileLargeFrames[676] = 2;
        tileFrameImportant[410] = true;
        tileFrameImportant[480] = true;
        tileFrameImportant[509] = true;
        tileFrameImportant[657] = true;
        tileFrameImportant[658] = true;
        tileLighted[658] = true;
        wallHouse[173] = true;
        wallHouse[183] = true;
        wallHouse[179] = true;
        wallLargeFrames[179] = 1;
        tileSolid[367] = true;
        tileBlockLight[367] = true;
        tileMergeDirt[367] = true;
        tileSolid[357] = true;
        tileBlockLight[357] = true;
        tileLargeFrames[357] = 1;
        tileBlendAll[357] = true;
        wallHouse[184] = true;
        wallHouse[181] = true;
        tileSolid[368] = true;
        tileBlockLight[368] = true;
        tileMergeDirt[368] = true;
        tileSolid[369] = true;
        tileBlockLight[369] = true;
        tileBrick[369] = true;
        tileMergeDirt[369] = true;
        wallHouse[186] = true;
        tileLargeFrames[325] = 1;
        tileSolid[325] = true;
        tileBlockLight[325] = true;
        wallLargeFrames[146] = 1;
        wallLargeFrames[147] = 1;
        wallLargeFrames[167] = 1;
        wallLargeFrames[185] = 2;
        wallLargeFrames[274] = 2;
        tileSolid[460] = true;
        tileSolid[326] = true;
        tileBlockLight[326] = true;
        tileBrick[326] = true;
        tileSolid[458] = true;
        tileBlockLight[458] = true;
        tileBrick[458] = true;
        tileSolid[459] = true;
        tileBrick[459] = true;
        tileSolid[327] = true;
        tileBlockLight[327] = true;
        tileBrick[327] = true;
        tileSolid[345] = true;
        tileBlockLight[345] = true;
        tileBrick[345] = true;
        tileLighted[327] = true;
        tileSolid[328] = true;
        tileBrick[328] = true;
        tileSolid[329] = true;
        tileBrick[329] = true;
        tileBlockLight[329] = true;
        tileSolid[507] = true;
        tileBlockLight[507] = true;
        tileBrick[507] = true;
        tileSolid[508] = true;
        tileBlockLight[508] = true;
        tileBrick[508] = true;
        tileLighted[336] = true;
        tileLighted[340] = true;
        tileLighted[341] = true;
        tileLighted[342] = true;
        tileLighted[343] = true;
        tileLighted[344] = true;
        tileLighted[349] = true;
        tileLighted[598] = true;
        tileSolid[421] = true;
        tileBlockLight[421] = true;
        tileSolid[422] = true;
        tileBlockLight[422] = true;
        tileSolid[426] = true;
        tileBlockLight[426] = true;
        tileSolid[430] = true;
        tileBlockLight[430] = true;
        tileSolid[431] = true;
        tileBlockLight[431] = true;
        tileSolid[432] = true;
        tileBlockLight[432] = true;
        tileSolid[433] = true;
        tileBlockLight[433] = true;
        tileSolid[434] = true;
        tileBlockLight[434] = true;
        tileSolid[446] = true;
        tileSolid[447] = true;
        tileSolid[448] = true;
        tileFrameImportant[427] = true;
        tileSolidTop[427] = true;
        tileSolid[427] = true;
        tileNoAttach[427] = true;
        tileTable[427] = true;
        tileLavaDeath[427] = true;
        tileNoSunLight[427] = false;
        tileSolid[476] = true;
        for (int num = 435; num <= 439; num++)
        {
            tileFrameImportant[num] = true;
            tileSolidTop[num] = true;
            tileSolid[num] = true;
            tileNoAttach[num] = true;
            tileTable[num] = true;
            tileLavaDeath[num] = true;
            tileNoSunLight[num] = false;
        }
        tileSolid[284] = true;
        tileBlockLight[284] = true;
        tileSolid[346] = true;
        tileBlockLight[346] = true;
        tileLighted[346] = true;
        tileShine[346] = 2000;
        tileShine2[346] = true;
        tileBrick[346] = true;
        tileMergeDirt[346] = true;
        tileSolid[347] = true;
        tileBlockLight[347] = true;
        tileLighted[347] = true;
        tileShine[347] = 1900;
        tileShine2[347] = true;
        tileBrick[347] = true;
        tileMergeDirt[347] = true;
        tileSolid[348] = true;
        tileBlockLight[348] = true;
        tileLighted[348] = true;
        tileShine[348] = 1800;
        tileShine2[348] = true;
        tileBrick[348] = true;
        tileMergeDirt[348] = true;
        tileSolid[350] = true;
        tileBlockLight[350] = true;
        tileLighted[350] = true;
        tileBrick[350] = true;
        tileMergeDirt[350] = true;
        tileGlowMask[350] = 94;
        tileGlowMask[390] = 130;
        tileGlowMask[381] = 126;
        tileGlowMask[517] = 258;
        tileGlowMask[687] = 336;
        tileGlowMask[534] = 259;
        tileGlowMask[535] = 260;
        tileGlowMask[689] = 338;
        tileGlowMask[536] = 261;
        tileGlowMask[537] = 262;
        tileGlowMask[690] = 339;
        tileGlowMask[539] = 263;
        tileGlowMask[540] = 264;
        tileGlowMask[688] = 337;
        tileGlowMask[625] = 311;
        tileGlowMask[626] = 312;
        tileGlowMask[691] = 340;
        tileGlowMask[627] = 313;
        tileGlowMask[628] = 314;
        tileGlowMask[692] = 341;
        tileGlowMask[370] = 111;
        tileGlowMask[429] = 214;
        tileGlowMask[209] = 215;
        tileGlowMask[445] = 214;
        tileGlowMask[129] = -2;
        tileGlowMask[633] = 326;
        tileGlowMask[659] = 348;
        tileGlowMask[667] = 349;
        tileLighted[429] = true;
        tileLighted[209] = true;
        tileGlowMask[410] = 201;
        tileGlowMask[509] = 265;
        tileGlowMask[658] = 333;
        tileSolid[370] = true;
        tileBlockLight[370] = true;
        tileLighted[370] = true;
        tileShine[370] = 1900;
        tileShine2[370] = true;
        tileBrick[370] = true;
        tileMergeDirt[370] = true;
        tileContainer[21] = true;
        tileContainer[467] = true;
        tileContainer[88] = true;
        tileContainer[470] = true;
        tileContainer[475] = true;
        tileSign[55] = true;
        tileSign[85] = true;
        tileSign[425] = true;
        tileSign[573] = true;
        tileSolid[383] = true;
        tileBrick[383] = true;
        tileBlockLight[383] = true;
        tileSolid[385] = true;
        tileBrick[385] = true;
        tileBlockLight[385] = true;
        tileSolid[472] = true;
        tileBrick[472] = true;
        tileMergeDirt[472] = true;
        tileBlockLight[472] = true;
        tileSolid[473] = true;
        tileBrick[473] = true;
        tileMergeDirt[473] = true;
        tileBlockLight[473] = true;
        tileSolid[500] = true;
        tileBrick[500] = true;
        tileLighted[500] = true;
        tileMergeDirt[500] = true;
        tileBlockLight[500] = true;
        tileSolid[501] = true;
        tileBrick[501] = true;
        tileLighted[501] = true;
        tileMergeDirt[501] = true;
        tileBlockLight[501] = true;
        tileSolid[502] = true;
        tileBrick[502] = true;
        tileLighted[502] = true;
        tileMergeDirt[502] = true;
        tileBlockLight[502] = true;
        tileSolid[503] = true;
        tileBrick[503] = true;
        tileLighted[503] = true;
        tileMergeDirt[503] = true;
        tileBlockLight[503] = true;
        tileSolid[541] = true;
        tileBlockLight[541] = false;
        tileSolid[546] = true;
        tileBlockLight[546] = false;
        tileSolid[557] = true;
        tileBlockLight[557] = true;
        tileSolid[474] = true;
        tileBrick[474] = true;
        tileMergeDirt[474] = true;
        tileBlockLight[474] = true;
        tileSolid[478] = true;
        tileBrick[478] = true;
        tileMergeDirt[478] = true;
        tileBlockLight[478] = true;
        tileSolid[479] = true;
        tileBrick[479] = true;
        tileMergeDirt[479] = true;
        tileBlockLight[479] = true;
        tileSolid[562] = true;
        tileBrick[562] = true;
        tileBlockLight[562] = true;
        tileMergeDirt[562] = true;
        tileSolid[563] = true;
        tileBrick[563] = true;
        tileBlockLight[563] = true;
        tileMergeDirt[563] = true;
        tileSolid[496] = true;
        tileBrick[496] = true;
        tileMergeDirt[496] = true;
        tileBlockLight[496] = true;
        tileSolid[495] = true;
        tileBrick[495] = true;
        tileMergeDirt[495] = true;
        tileBlockLight[495] = true;
        tileSolid[396] = true;
        tileBlockLight[396] = true;
        tileSolid[397] = true;
        tileBlockLight[397] = true;
        tileSolid[399] = true;
        tileBlockLight[399] = true;
        tileSolid[401] = true;
        tileBlockLight[401] = true;
        tileSolid[398] = true;
        tileBlockLight[398] = true;
        tileSolid[400] = true;
        tileBlockLight[400] = true;
        tileSolid[402] = true;
        tileBlockLight[402] = true;
        tileSolid[403] = true;
        tileBlockLight[403] = true;
        tileSolid[404] = true;
        tileBlockLight[404] = true;
        tileSolid[407] = true;
        tileBlockLight[407] = true;
        tileShine2[407] = true;
        tileShine[407] = 1000;
        tileFrameImportant[36] = true;
        tileFrameImportant[275] = true;
        tileFrameImportant[276] = true;
        tileFrameImportant[277] = true;
        tileFrameImportant[278] = true;
        tileFrameImportant[279] = true;
        tileFrameImportant[280] = true;
        tileFrameImportant[281] = true;
        tileFrameImportant[282] = true;
        tileFrameImportant[285] = true;
        tileFrameImportant[286] = true;
        tileFrameImportant[414] = true;
        tileFrameImportant[413] = true;
        tileFrameImportant[309] = true;
        tileFrameImportant[310] = true;
        tileFrameImportant[339] = true;
        tileFrameImportant[532] = true;
        tileLighted[286] = true;
        tileLighted[302] = true;
        tileFrameImportant[298] = true;
        tileFrameImportant[299] = true;
        tileSolid[170] = true;
        tileBlockLight[170] = true;
        tileFrameImportant[171] = true;
        tileLighted[171] = true;
        tileFrameImportant[247] = true;
        tileFrameImportant[245] = true;
        tileFrameImportant[246] = true;
        tileFrameImportant[239] = true;
        tileFrameImportant[240] = true;
        tileFrameImportant[241] = true;
        tileFrameImportant[242] = true;
        tileFrameImportant[243] = true;
        tileFrameImportant[244] = true;
        tileFrameImportant[254] = true;
        tileSolid[221] = true;
        tileBlockLight[221] = true;
        tileMergeDirt[221] = true;
        tileLighted[96] = true;
        tileMergeDirt[250] = true;
        tileSolid[272] = true;
        tileBlockLight[272] = true;
        tileSolid[229] = true;
        tileBlockLight[229] = true;
        tileMergeDirt[229] = true;
        tileSolid[230] = true;
        tileBlockLight[230] = true;
        tileMergeDirt[230] = true;
        tileSolid[222] = true;
        tileBlockLight[222] = true;
        tileMergeDirt[222] = true;
        tileSolid[223] = true;
        tileBlockLight[223] = true;
        tileMergeDirt[223] = true;
        tileSolid[224] = true;
        tileBlockLight[224] = true;
        tileFrameImportant[237] = true;
        tileFrameImportant[238] = true;
        tileSolid[225] = true;
        tileBlockLight[225] = true;
        tileBrick[225] = true;
        tileSolid[226] = true;
        tileBlockLight[226] = true;
        tileBrick[226] = true;
        tileSolid[235] = true;
        tileBlockLight[235] = true;
        tileFrameImportant[235] = true;
        tileLighted[238] = true;
        tileCut[254] = true;
        tileFrameImportant[236] = true;
        tileCut[236] = true;
        tileSolid[191] = true;
        tileBrick[191] = true;
        tileBlockLight[191] = true;
        tileSolid[211] = true;
        tileBlockLight[211] = true;
        tileSolid[208] = true;
        tileBrick[208] = true;
        tileBlockLight[208] = true;
        tileSolid[192] = true;
        tileBlockLight[192] = true;
        tileSolid[193] = true;
        tileBrick[193] = true;
        tileBlockLight[193] = true;
        tileMergeDirt[193] = true;
        tileSolid[194] = true;
        tileBrick[194] = true;
        tileBlockLight[194] = true;
        tileSolid[195] = true;
        tileBrick[195] = true;
        tileMergeDirt[195] = true;
        tileBlockLight[195] = true;
        tileBlockLight[200] = true;
        tileSolid[200] = true;
        tileBrick[200] = true;
        tileBlockLight[203] = true;
        tileSolid[203] = true;
        tileMergeDirt[203] = true;
        tileBlockLight[204] = true;
        tileSolid[204] = true;
        tileMergeDirt[204] = true;
        tileBlockLight[165] = true;
        tileShine2[147] = true;
        tileShine2[161] = true;
        tileShine2[163] = true;
        tileShine2[164] = true;
        tileSolid[189] = true;
        tileBlockLight[51] = true;
        tileLighted[204] = true;
        tileShine[204] = 1150;
        tileShine2[204] = true;
        tileSolid[190] = true;
        tileBlockLight[190] = true;
        tileBrick[190] = true;
        tileSolid[198] = true;
        tileMergeDirt[198] = true;
        tileBrick[198] = true;
        tileBlockLight[198] = true;
        tileSolid[206] = true;
        tileBlockLight[206] = true;
        tileMergeDirt[206] = true;
        tileBrick[206] = true;
        tileBlockLight[234] = true;
        tileSolid[248] = true;
        tileSolid[249] = true;
        tileSolid[250] = true;
        tileBrick[248] = true;
        tileBrick[249] = true;
        tileBrick[250] = true;
        tileSolid[251] = true;
        tileSolid[252] = true;
        tileBrick[252] = true;
        tileSolid[253] = true;
        tileBrick[253] = true;
        tileMergeDirt[251] = true;
        tileMergeDirt[252] = true;
        tileMergeDirt[253] = true;
        tileBlockLight[251] = true;
        tileBlockLight[252] = true;
        tileBlockLight[253] = true;
        tileBlockLight[248] = true;
        tileBlockLight[249] = true;
        tileBlockLight[250] = true;
        tileLargeFrames[273] = 1;
        tileSolid[273] = true;
        tileBlockLight[273] = true;
        tileLargeFrames[274] = 1;
        tileSolid[274] = true;
        tileBlockLight[274] = true;
        tileLargeFrames[618] = 1;
        tileSolid[618] = true;
        tileBlockLight[618] = true;
        for (int num2 = 255; num2 <= 268; num2++)
        {
            tileSolid[num2] = true;
            if (num2 > 261)
            {
                tileLighted[num2] = true;
                tileShine2[num2] = true;
            }
        }
        tileFrameImportant[269] = true;
        tileFrameImportant[470] = true;
        tileFrameImportant[475] = true;
        tileFrameImportant[390] = true;
        tileFrameImportant[597] = true;
        tileLighted[597] = true;
        tileNoAttach[390] = true;
        tileLavaDeath[390] = true;
        tileLighted[390] = true;
        tileFrameImportant[617] = true;
        wallHouse[168] = true;
        wallHouse[169] = true;
        wallHouse[142] = true;
        wallHouse[143] = true;
        wallHouse[144] = true;
        wallHouse[149] = true;
        wallHouse[151] = true;
        wallHouse[150] = true;
        wallHouse[152] = true;
        wallHouse[145] = true;
        wallHouse[148] = true;
        wallHouse[175] = true;
        wallHouse[176] = true;
        wallHouse[182] = true;
        for (int num3 = 153; num3 < 167; num3++)
        {
            wallHouse[num3] = true;
        }
        wallHouse[146] = true;
        wallHouse[147] = true;
        wallHouse[149] = true;
        wallHouse[167] = true;
        wallHouse[168] = true;
        wallHouse[133] = true;
        wallHouse[134] = true;
        wallHouse[135] = true;
        wallHouse[136] = true;
        wallHouse[137] = true;
        wallHouse[75] = true;
        wallHouse[76] = true;
        wallHouse[78] = true;
        wallHouse[82] = true;
        wallHouse[77] = true;
        wallHouse[1] = true;
        wallHouse[4] = true;
        wallHouse[5] = true;
        wallHouse[6] = true;
        wallHouse[10] = true;
        wallHouse[11] = true;
        wallHouse[12] = true;
        wallHouse[16] = true;
        wallHouse[17] = true;
        wallHouse[18] = true;
        wallHouse[19] = true;
        wallHouse[20] = true;
        wallHouse[21] = true;
        wallHouse[22] = true;
        wallHouse[23] = true;
        wallHouse[24] = true;
        wallHouse[25] = true;
        wallHouse[26] = true;
        wallHouse[27] = true;
        wallHouse[29] = true;
        wallHouse[30] = true;
        wallHouse[31] = true;
        wallHouse[32] = true;
        wallHouse[33] = true;
        wallHouse[34] = true;
        wallHouse[35] = true;
        wallHouse[36] = true;
        wallHouse[37] = true;
        wallHouse[38] = true;
        wallHouse[39] = true;
        wallHouse[41] = true;
        wallHouse[42] = true;
        wallHouse[43] = true;
        wallHouse[44] = true;
        wallHouse[45] = true;
        wallHouse[46] = true;
        wallHouse[47] = true;
        wallHouse[66] = true;
        wallHouse[67] = true;
        wallHouse[68] = true;
        wallHouse[72] = true;
        wallHouse[73] = true;
        wallHouse[107] = true;
        wallHouse[106] = true;
        wallHouse[245] = true;
        wallHouse[315] = true;
        wallHouse[316] = true;
        wallHouse[317] = true;
        wallHouse[109] = true;
        wallHouse[110] = true;
        wallHouse[111] = true;
        wallHouse[112] = true;
        wallHouse[113] = true;
        wallHouse[114] = true;
        wallHouse[115] = true;
        wallHouse[116] = true;
        wallHouse[117] = true;
        wallHouse[118] = true;
        wallHouse[119] = true;
        wallHouse[120] = true;
        wallHouse[121] = true;
        wallHouse[122] = true;
        wallHouse[123] = true;
        wallHouse[124] = true;
        wallHouse[125] = true;
        wallHouse[108] = true;
        wallHouse[100] = true;
        wallHouse[101] = true;
        wallHouse[102] = true;
        wallHouse[103] = true;
        wallHouse[104] = true;
        wallHouse[105] = true;
        wallHouse[84] = true;
        wallHouse[74] = true;
        wallHouse[241] = true;
        wallHouse[85] = true;
        wallHouse[88] = true;
        wallHouse[89] = true;
        wallHouse[90] = true;
        wallHouse[91] = true;
        wallHouse[92] = true;
        wallHouse[93] = true;
        wallHouse[126] = true;
        wallHouse[127] = true;
        wallHouse[128] = true;
        wallHouse[129] = true;
        wallHouse[130] = true;
        wallHouse[131] = true;
        wallHouse[132] = true;
        wallHouse[138] = true;
        wallHouse[139] = true;
        wallHouse[140] = true;
        wallHouse[141] = true;
        wallHouse[177] = true;
        wallHouse[172] = true;
        wallHouse[242] = true;
        wallHouse[243] = true;
        wallHouse[174] = true;
        wallHouse[223] = true;
        wallHouse[230] = true;
        wallHouse[228] = true;
        wallHouse[229] = true;
        wallHouse[236] = true;
        wallHouse[319] = true;
        wallHouse[318] = true;
        wallHouse[321] = true;
        wallHouse[322] = true;
        wallHouse[320] = true;
        wallHouse[246] = true;
        wallHouse[247] = true;
        wallHouse[248] = true;
        wallHouse[249] = true;
        wallHouse[250] = true;
        wallHouse[251] = true;
        wallHouse[252] = true;
        wallHouse[253] = true;
        wallHouse[254] = true;
        wallHouse[255] = true;
        wallHouse[314] = true;
        wallHouse[256] = true;
        wallHouse[257] = true;
        wallHouse[258] = true;
        wallHouse[259] = true;
        wallHouse[260] = true;
        wallHouse[261] = true;
        wallHouse[262] = true;
        wallHouse[263] = true;
        wallHouse[264] = true;
        wallHouse[265] = true;
        wallHouse[266] = true;
        wallHouse[267] = true;
        wallHouse[268] = true;
        wallHouse[269] = true;
        wallHouse[270] = true;
        wallHouse[271] = true;
        wallHouse[272] = true;
        wallHouse[273] = true;
        wallHouse[274] = true;
        wallHouse[275] = true;
        wallHouse[276] = true;
        wallHouse[277] = true;
        wallHouse[278] = true;
        wallHouse[279] = true;
        wallHouse[280] = true;
        wallHouse[281] = true;
        wallHouse[282] = true;
        wallHouse[283] = true;
        wallHouse[284] = true;
        wallHouse[285] = true;
        wallHouse[286] = true;
        wallHouse[287] = true;
        wallHouse[288] = true;
        wallHouse[289] = true;
        wallHouse[290] = true;
        wallHouse[291] = true;
        wallHouse[292] = true;
        wallHouse[293] = true;
        wallHouse[294] = true;
        wallHouse[295] = true;
        wallHouse[296] = true;
        wallHouse[297] = true;
        wallHouse[298] = true;
        wallHouse[299] = true;
        wallHouse[300] = true;
        wallHouse[301] = true;
        wallHouse[302] = true;
        wallHouse[303] = true;
        wallHouse[304] = true;
        wallHouse[305] = true;
        wallHouse[306] = true;
        wallHouse[307] = true;
        wallHouse[308] = true;
        wallHouse[309] = true;
        wallHouse[310] = true;
        wallHouse[311] = true;
        wallLight[0] = true;
        wallLight[21] = true;
        wallLight[318] = true;
        wallLight[106] = true;
        wallLight[317] = true;
        wallLight[107] = true;
        wallLight[138] = true;
        wallLight[140] = true;
        wallLight[141] = true;
        wallLight[139] = true;
        wallLight[145] = true;
        wallLight[150] = true;
        wallLight[152] = true;
        wallLight[245] = true;
        wallLight[315] = true;
        wallLight[168] = true;
        for (int num4 = 0; num4 < WallID.Count; num4++)
        {
            wallDungeon[num4] = false;
        }
        wallDungeon[7] = true;
        wallDungeon[8] = true;
        wallDungeon[9] = true;
        wallDungeon[94] = true;
        wallDungeon[95] = true;
        wallDungeon[96] = true;
        wallDungeon[97] = true;
        wallDungeon[98] = true;
        wallDungeon[99] = true;
        SetupTileMerge();
    }
 
    private void ClientInitialize()
    {
        //IL_01cc: Unknown result type (might be due to invalid IL or missing references)
        //IL_01d6: Expected O, but got Unknown
        MessageBuffer.OnTileChangeReceived += OnTileChangeEvent;
        LanguageManager.Instance.OnLanguageChanged += delegate
        {
            ItemTooltip.InvalidateTooltips();
        };
        PlayerInput.OnBindingChange += ItemTooltip.InvalidateTooltips;
        clientUUID = Guid.NewGuid().ToString();
        _ = Terraria.Graphics.Effects.Filters.Scene;
        Platform.Current.InitializeClientServices(base.Window.Handle);
        Platform.Get<IImeService>().AddKeyListener((Action<char>)delegate(char keyStroke)
        {
            if (keyCount < 10)
            {
                keyInt[keyCount] = keyStroke;
                keyString[keyCount] = keyStroke.ToString() ?? "";
                keyCount++;
            }
        });
        base.Window.AllowUserResizing = true;
        LoadSettings();
        PreventUpdatingTargets = false;
        SetDisplayMonitor();
        PlayerInput.CacheOriginalScreenDimensions();
        if (screenWidth > GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width)
        {
            screenWidth = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width;
        }
        if (screenHeight > GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height)
        {
            screenHeight = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height;
        }
        UpdateDisplaySettings();
        graphics.ApplyChanges();
        if (Main.OnResolutionChanged != null)
        {
            Main.OnResolutionChanged(new Vector2(screenWidth, screenHeight));
        }
        CheckBunny();
        base.GraphicsDevice.DeviceLost += GraphicsDeviceLost;
        base.GraphicsDevice.DeviceReset += GraphicsDeviceLost;
        base.GraphicsDevice.DeviceResetting += GraphicsDeviceLost;
        if (_needsLanguageSelect)
        {
            menuMode = 1212;
        }
        _achievements = new AchievementManager();
        _achievementAdvisor = new AchievementAdvisor();
        OpenRecent();
        UILinksInitializer.Load();
        Chroma = new ChromaEngine();
        ChromaPainter = new ChromaHotkeyPainter();
        ChromaPainter.CollectBoundKeys();
        CacheSupportedDisplaySizes();
        if (autoJoin)
        {
            LoadPlayers();
            menuMode = 1;
            menuMultiplayer = true;
        }
        fpsTimer.Start();
    }
 
    private static void CacheSupportedDisplaySizes()
    {
        numDisplayModes = 0;
        foreach (DisplayMode supportedDisplayMode in GraphicsAdapter.DefaultAdapter.SupportedDisplayModes)
        {
            if (supportedDisplayMode.Width < minScreenW || supportedDisplayMode.Height < minScreenH || supportedDisplayMode.Width > maxScreenW || supportedDisplayMode.Height > maxScreenH)
            {
                continue;
            }
            bool flag = true;
            for (int i = 0; i < numDisplayModes; i++)
            {
                if (supportedDisplayMode.Width == displayWidth[i] && supportedDisplayMode.Height == displayHeight[i])
                {
                    flag = false;
                    break;
                }
            }
            if (flag)
            {
                displayHeight[numDisplayModes] = supportedDisplayMode.Height;
                displayWidth[numDisplayModes] = supportedDisplayMode.Width;
                numDisplayModes++;
            }
        }
    }
 
    public static void LoadTestLog(string logname)
    {
    }
 
    private void OnceFailedLoadingAnAsset(string assetPath, Exception e)
    {
        FancyErrorPrinter.ShowFailedToLoadAssetError(e, assetPath);
    }
 
    protected override void LoadContent()
    {
        //IL_0039: Unknown result type (might be due to invalid IL or missing references)
        //IL_0043: Expected O, but got Unknown
        //IL_0108: Unknown result type (might be due to invalid IL or missing references)
        //IL_0112: Expected O, but got Unknown
        //IL_0167: Unknown result type (might be due to invalid IL or missing references)
        //IL_016d: Expected O, but got Unknown
        SoundEngine.Initialize();
        if (XnaExtensions.Get<IAssetRepository>((IServiceProvider)base.Services) == null)
        {
            AssetInitializer.CreateAssetServices(base.Services);
        }
        Assets = XnaExtensions.Get<IAssetRepository>((IServiceProvider)base.Services);
        Assets.AssetLoadFailHandler = new FailedToLoadAssetCustomAction(OnceFailedLoadingAnAsset);
        mapSectionTexture = new RenderTarget2D(base.GraphicsDevice, 200, 150);
        ShaderContentManager = new ContentManager(base.Content.ServiceProvider, base.Content.RootDirectory);
        PixelShaderRef.Value = ShaderContentManager.Load<Effect>("PixelShader");
        VertexPixelShaderRef.Value = ShaderContentManager.Load<Effect>("PixelShader");
        TileShaderRef.Value = ShaderContentManager.Load<Effect>("TileShader");
        ScreenShaderRef.Value = ShaderContentManager.Load<Effect>("ScreenShader");
        spriteBatch = new SpriteBatch(base.GraphicsDevice);
        tileBatch = new TileBatch(base.GraphicsDevice);
        DebugDrawer = new BasicDebugDrawer(base.GraphicsDevice);
        GameViewMatrix = new SpriteViewMatrix(base.GraphicsDevice);
        BackgroundViewMatrix = new SpriteViewMatrix(base.GraphicsDevice);
        if (SoundEngine.IsAudioSupported)
        {
            audioSystem = new LegacyAudioSystem();
        }
        else
        {
            audioSystem = new DisabledAudioSystem();
        }
        AssetSourceController = new AssetSourceController(Assets, (IEnumerable<IContentSource>)(object)new IContentSource[1] { (IContentSource)new XnaContentSource(base.Content.RootDirectory) });
        VanillaContentValidator.Instance = new VanillaContentValidator("Terraria.IO.Data.ResourcePacksDefaultInfo.tsv");
        if (SocialAPI.Workshop != null)
        {
            SocialAPI.Workshop.LoadEarlyContent();
        }
        AssetSourceController.UseResourcePacks(AssetInitializer.CreateResourcePackList(base.Services));
        AssetInitializer.LoadSplashAssets(asyncLoadForSounds: true);
        ChromaInitializer.Load();
        _gameContentLoadProcess = LoadContent_Deferred();
    }
 
    private void LoadContent_TryEnteringHiDef()
    {
        Configuration.Load();
        Configuration.Get("UseExperimentalFeatures", ref UseExperimentalFeatures);
        Configuration.Get("Support4K", ref Support4K);
        bool flag = Support4K && base.GraphicsDevice.Adapter.IsProfileSupported(GraphicsProfile.HiDef);
        if (GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width <= 1920 && GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height <= 1200)
        {
            flag = false;
        }
        if (Program.IsXna && Support4K && flag && base.GraphicsDevice.GraphicsProfile != GraphicsProfile.HiDef)
        {
            SetGraphicsProfile(GraphicsProfile.HiDef, forceSet: false);
        }
        else if (Program.IsFna)
        {
            SetGraphicsProfile(GraphicsProfile.HiDef, forceSet: true);
        }
    }
 
    protected IEnumerator LoadContent_Deferred()
    {
        yield return null;
        IssueReporter = new GeneralIssueReporter();
        AssetInitializer.LoadAssetsWhileInInitialBlackScreen();
        yield return null;
        bool doneLoadingMusic = false;
        IEnumerator musicLoadProcedure = LoadMusic_InSteps();
        while (!doneLoadingMusic)
        {
            try
            {
                if (!musicLoadProcedure.MoveNext())
                {
                    doneLoadingMusic = true;
                }
            }
            catch
            {
                doneLoadingMusic = true;
                musicVolume = 0f;
                soundVolume = 0f;
            }
            yield return null;
        }
        _musicLoaded = true;
        splashTimer.Start();
        yield return null;
        _begunMainAsyncLoad = true;
        AssetInitializer.Load(asyncLoad: true);
        _artLoaded = true;
        TownNPCHeadRenderer = new NPCHeadRenderer(TextureAssets.NpcHead);
        ContentThatNeedsRenderTargets.Add(TownNPCHeadRenderer);
        BossNPCHeadRenderer = new NPCHeadRenderer(TextureAssets.NpcHeadBoss);
        ContentThatNeedsRenderTargets.Add(BossNPCHeadRenderer);
    }
 
    private void TickLoadProcess()
    {
        _gameContentLoadProcess.MoveNext();
    }
 
    private static void PostContentLoadInitialize()
    {
        LiquidRenderer.LoadContent();
        AchievementInitializer.Load();
        AchievementAdvisor.Initialize();
        DyeInitializer.Load();
        ScreenEffectInitializer.Load();
        InGameNotificationsTracker.Initialize();
        LinkButtonsInitializer.Load();
        _stardewAnimation = new StardewValleyAnimation();
        moonType = rand.Next(9);
        windSpeedCurrent = (float)rand.Next(-800, 801) * 0.001f;
        windSpeedTarget = windSpeedCurrent;
        numClouds = rand.Next(200);
        Mount.Initialize();
        Minecart.Initialize();
        CacheSupportedDisplaySizes();
        ContentSamples.RebuildItemCreativeSortingIDsAfterRecipesAreSetUp();
        ContentSamples.CommonlyUsedContentSamples.PrepareAfterEverythingElseLoaded();
    }
 
    private IEnumerator LoadMusic_InSteps()
    {
        yield return null;
        IEnumerator sub1 = audioSystem.PrepareWaveBank();
        while (sub1.MoveNext())
        {
            yield return sub1.Current;
        }
        for (int i = 1; i < maxMusic; i++)
        {
            audioSystem.LoadCue(i, "Music_" + i);
            yield return null;
        }
        audioSystem.LoadFromSources();
    }
 
    protected override void UnloadContent()
    {
    }
 
    public static void CheckForMoonEventsStartingTemporarySeasons()
    {
        if (netMode != 1)
        {
            bool num = forceHalloweenForToday;
            bool flag = forceXMasForToday;
            forceXMasForToday = false;
            forceHalloweenForToday = false;
            int waveNumber = NPC.waveNumber;
            _ = NPC.waveKills;
            if (pumpkinMoon && waveNumber >= 15)
            {
                forceHalloweenForToday = true;
            }
            if (snowMoon && waveNumber >= 15)
            {
                forceXMasForToday = true;
            }
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(50, 255, 130);
            if (num != forceHalloweenForToday)
            {
                WorldGen.BroadcastText(NetworkText.FromKey(forceHalloweenForToday ? "Misc.StartedVictoryHalloween" : "Misc.EndedVictoryHalloween"), color);
            }
            if (flag != forceXMasForToday)
            {
                WorldGen.BroadcastText(NetworkText.FromKey(forceXMasForToday ? "Misc.StartedVictoryXmas" : "Misc.EndedVictoryXmas"), color);
            }
        }
    }
 
    public static void CheckForMoonEventsScoreDisplay()
    {
        if (netMode != 1 && (pumpkinMoon || snowMoon))
        {
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(175, 75, 255);
            string key = "Misc.PumpkinMoonScore";
            if (snowMoon)
            {
                key = "Misc.FrostMoonScore";
            }
            WorldGen.BroadcastText(NetworkText.FromKey(key, NPC.totalInvasionPoints), color);
        }
    }
 
    public static void stopMoonEvent()
    {
        _ = NPC.waveNumber;
        _ = NPC.waveKills;
        if (pumpkinMoon)
        {
            pumpkinMoon = false;
            if (netMode != 1)
            {
                NPC.totalInvasionPoints = 0f;
                NPC.waveKills = 0f;
                NPC.waveNumber = 0;
            }
        }
        if (snowMoon)
        {
            snowMoon = false;
            if (netMode != 1)
            {
                NPC.totalInvasionPoints = 0f;
                NPC.waveKills = 0f;
                NPC.waveNumber = 0;
            }
        }
    }
 
    public static void startPumpkinMoon()
    {
        pumpkinMoon = true;
        snowMoon = false;
        bloodMoon = false;
        invasionProgress = -1;
        invasionProgressDisplayLeft = 0;
        invasionProgressAlpha = 0f;
        invasionProgressIcon = 0;
        if (netMode != 1)
        {
            NPC.totalInvasionPoints = 0f;
            NPC.waveKills = 0f;
            NPC.waveNumber = 1;
            NetworkText invasionWaveText = Lang.GetInvasionWaveText(1, 305);
            if (netMode == 0)
            {
                NewText(invasionWaveText.ToString(), 175, 75);
            }
            else if (netMode == 2)
            {
                ChatHelper.BroadcastChatMessage(invasionWaveText, new Microsoft.Xna.Framework.Color(175, 75, 255));
            }
        }
    }
 
    public static void startSnowMoon()
    {
        snowMoon = true;
        pumpkinMoon = false;
        bloodMoon = false;
        invasionProgress = -1;
        invasionProgressDisplayLeft = 0;
        invasionProgressAlpha = 0f;
        invasionProgressIcon = 0;
        if (netMode != 1)
        {
            NPC.totalInvasionPoints = 0f;
            NPC.waveKills = 0f;
            NPC.waveNumber = 1;
            NetworkText invasionWaveText = Lang.GetInvasionWaveText(1, 338, 342);
            if (netMode == 0)
            {
                NewText(invasionWaveText.ToString(), 175, 75);
            }
            else if (netMode == 2)
            {
                ChatHelper.BroadcastChatMessage(invasionWaveText, new Microsoft.Xna.Framework.Color(175, 75, 255));
            }
        }
    }
 
    protected void UpdateAudio()
    {
        if (!SoundEngine.IsAudioSupported || !_musicLoaded)
        {
            return;
        }
        if (!dedServ && !showSplash)
        {
            SoundEngine.Update();
        }
        if (musicVolume == 0f)
        {
            curMusic = 0;
        }
        try
        {
            if (dedServ)
            {
                return;
            }
            bool flag = base.IsActive;
            if (!flag)
            {
                audioSystem.PauseAll();
                SoundEngine.StopAmbientSounds();
            }
            else
            {
                audioSystem.ResumeAll();
            }
            if (drunkWorld)
            {
                TOWMusicUnlocked = true;
            }
            if (gameMenu)
            {
                swapMusic = false;
            }
            if (swapMusic)
            {
                if (drunkWorld && !remixWorld)
                {
                    UpdateAudio_DecideOnNewMusic();
                }
                else
                {
                    UpdateAudio_DecideOnTOWMusic();
                }
            }
            else if (!gameMenu && drunkWorld && !remixWorld)
            {
                UpdateAudio_DecideOnTOWMusic();
            }
            else
            {
                UpdateAudio_DecideOnNewMusic();
            }
            if (musicBox2 >= 0)
            {
                SceneMetrics.ActiveMusicBox = musicBox2;
            }
            if (SceneMetrics.ActiveMusicBox >= 0)
            {
                if (SceneMetrics.ActiveMusicBox == 0)
                {
                    newMusic = 1;
                }
                if (SceneMetrics.ActiveMusicBox == 1)
                {
                    newMusic = 2;
                }
                if (SceneMetrics.ActiveMusicBox == 2)
                {
                    newMusic = 3;
                }
                if (SceneMetrics.ActiveMusicBox == 4)
                {
                    newMusic = 4;
                }
                if (SceneMetrics.ActiveMusicBox == 5)
                {
                    newMusic = 5;
                }
                if (SceneMetrics.ActiveMusicBox == 3)
                {
                    newMusic = 6;
                }
                if (SceneMetrics.ActiveMusicBox == 6)
                {
                    newMusic = 7;
                }
                if (SceneMetrics.ActiveMusicBox == 7)
                {
                    newMusic = 8;
                }
                if (SceneMetrics.ActiveMusicBox == 9)
                {
                    newMusic = 9;
                }
                if (SceneMetrics.ActiveMusicBox == 8)
                {
                    newMusic = 10;
                }
                if (SceneMetrics.ActiveMusicBox == 11)
                {
                    newMusic = 11;
                }
                if (SceneMetrics.ActiveMusicBox == 10)
                {
                    newMusic = 12;
                }
                if (SceneMetrics.ActiveMusicBox == 12)
                {
                    newMusic = 13;
                }
                if (SceneMetrics.ActiveMusicBox == 13)
                {
                    newMusic = 14;
                }
                if (SceneMetrics.ActiveMusicBox == 14)
                {
                    newMusic = 15;
                }
                if (SceneMetrics.ActiveMusicBox == 15)
                {
                    newMusic = 16;
                }
                if (SceneMetrics.ActiveMusicBox == 16)
                {
                    newMusic = 17;
                }
                if (SceneMetrics.ActiveMusicBox == 17)
                {
                    newMusic = 18;
                }
                if (SceneMetrics.ActiveMusicBox == 18)
                {
                    newMusic = 19;
                }
                if (SceneMetrics.ActiveMusicBox == 19)
                {
                    newMusic = 20;
                }
                if (SceneMetrics.ActiveMusicBox == 20)
                {
                    newMusic = 21;
                }
                if (SceneMetrics.ActiveMusicBox == 21)
                {
                    newMusic = 22;
                }
                if (SceneMetrics.ActiveMusicBox == 22)
                {
                    newMusic = 23;
                }
                if (SceneMetrics.ActiveMusicBox == 23)
                {
                    newMusic = 24;
                }
                if (SceneMetrics.ActiveMusicBox == 24)
                {
                    newMusic = 25;
                }
                if (SceneMetrics.ActiveMusicBox == 25)
                {
                    newMusic = 26;
                }
                if (SceneMetrics.ActiveMusicBox == 26)
                {
                    newMusic = 27;
                }
                if (SceneMetrics.ActiveMusicBox == 27)
                {
                    newMusic = 29;
                }
                if (SceneMetrics.ActiveMusicBox == 28)
                {
                    newMusic = 30;
                }
                if (SceneMetrics.ActiveMusicBox == 29)
                {
                    newMusic = 31;
                }
                if (SceneMetrics.ActiveMusicBox == 30)
                {
                    newMusic = 32;
                }
                if (SceneMetrics.ActiveMusicBox == 31)
                {
                    newMusic = 33;
                }
                if (SceneMetrics.ActiveMusicBox == 32)
                {
                    newMusic = 38;
                }
                if (SceneMetrics.ActiveMusicBox == 33)
                {
                    newMusic = 37;
                }
                if (SceneMetrics.ActiveMusicBox == 34)
                {
                    newMusic = 35;
                }
                if (SceneMetrics.ActiveMusicBox == 35)
                {
                    newMusic = 36;
                }
                if (SceneMetrics.ActiveMusicBox == 36)
                {
                    newMusic = 34;
                }
                if (SceneMetrics.ActiveMusicBox == 37)
                {
                    newMusic = 39;
                }
                if (SceneMetrics.ActiveMusicBox == 38)
                {
                    newMusic = 40;
                }
                if (SceneMetrics.ActiveMusicBox == 39)
                {
                    newMusic = 41;
                }
                if (SceneMetrics.ActiveMusicBox == 40)
                {
                    newMusic = 44;
                }
                if (SceneMetrics.ActiveMusicBox == 41)
                {
                    newMusic = 48;
                }
                if (SceneMetrics.ActiveMusicBox == 42)
                {
                    newMusic = 42;
                }
                if (SceneMetrics.ActiveMusicBox == 43)
                {
                    newMusic = 43;
                }
                if (SceneMetrics.ActiveMusicBox == 44)
                {
                    newMusic = 46;
                }
                if (SceneMetrics.ActiveMusicBox == 45)
                {
                    newMusic = 47;
                }
                if (SceneMetrics.ActiveMusicBox == 46)
                {
                    newMusic = 49;
                }
                if (SceneMetrics.ActiveMusicBox == 47)
                {
                    newMusic = 51;
                }
                if (SceneMetrics.ActiveMusicBox == 48)
                {
                    newMusic = 52;
                }
                if (SceneMetrics.ActiveMusicBox == 49)
                {
                    newMusic = 53;
                }
                if (SceneMetrics.ActiveMusicBox == 50)
                {
                    newMusic = 54;
                }
                if (SceneMetrics.ActiveMusicBox == 51)
                {
                    newMusic = 55;
                }
                if (SceneMetrics.ActiveMusicBox == 52)
                {
                    newMusic = 56;
                }
                if (SceneMetrics.ActiveMusicBox == 53)
                {
                    newMusic = 57;
                }
                if (SceneMetrics.ActiveMusicBox == 54)
                {
                    newMusic = 58;
                }
                if (SceneMetrics.ActiveMusicBox == 55)
                {
                    newMusic = 59;
                }
                if (SceneMetrics.ActiveMusicBox == 56)
                {
                    newMusic = 60;
                }
                if (SceneMetrics.ActiveMusicBox == 57)
                {
                    newMusic = 61;
                }
                if (SceneMetrics.ActiveMusicBox == 58)
                {
                    newMusic = 62;
                }
                if (SceneMetrics.ActiveMusicBox == 59)
                {
                    newMusic = 63;
                }
                if (SceneMetrics.ActiveMusicBox == 60)
                {
                    newMusic = 64;
                }
                if (SceneMetrics.ActiveMusicBox == 61)
                {
                    newMusic = 65;
                }
                if (SceneMetrics.ActiveMusicBox == 62)
                {
                    newMusic = 66;
                }
                if (SceneMetrics.ActiveMusicBox == 63)
                {
                    newMusic = 67;
                }
                if (SceneMetrics.ActiveMusicBox == 64)
                {
                    newMusic = 68;
                }
                if (SceneMetrics.ActiveMusicBox == 65)
                {
                    newMusic = 69;
                }
                if (SceneMetrics.ActiveMusicBox == 66)
                {
                    newMusic = 70;
                }
                if (SceneMetrics.ActiveMusicBox == 67)
                {
                    newMusic = 71;
                }
                if (SceneMetrics.ActiveMusicBox == 68)
                {
                    newMusic = 72;
                }
                if (SceneMetrics.ActiveMusicBox == 69)
                {
                    newMusic = 73;
                }
                if (SceneMetrics.ActiveMusicBox == 70)
                {
                    newMusic = 74;
                }
                if (SceneMetrics.ActiveMusicBox == 71)
                {
                    newMusic = 75;
                }
                if (SceneMetrics.ActiveMusicBox == 72)
                {
                    newMusic = 76;
                }
                if (SceneMetrics.ActiveMusicBox == 73)
                {
                    newMusic = 77;
                }
                if (SceneMetrics.ActiveMusicBox == 74)
                {
                    newMusic = 78;
                }
                if (SceneMetrics.ActiveMusicBox == 75)
                {
                    newMusic = 79;
                }
                if (SceneMetrics.ActiveMusicBox == 76)
                {
                    newMusic = 80;
                }
                if (SceneMetrics.ActiveMusicBox == 77)
                {
                    newMusic = 81;
                }
                if (SceneMetrics.ActiveMusicBox == 78)
                {
                    newMusic = 82;
                }
                if (SceneMetrics.ActiveMusicBox == 79)
                {
                    newMusic = 83;
                }
                if (SceneMetrics.ActiveMusicBox == 80)
                {
                    newMusic = 84;
                }
                if (SceneMetrics.ActiveMusicBox == 81)
                {
                    newMusic = 85;
                }
                if (SceneMetrics.ActiveMusicBox == 82)
                {
                    newMusic = 86;
                }
                if (SceneMetrics.ActiveMusicBox == 83)
                {
                    newMusic = 87;
                }
                if (SceneMetrics.ActiveMusicBox == 84)
                {
                    newMusic = 88;
                }
                if (SceneMetrics.ActiveMusicBox == 85)
                {
                    newMusic = 89;
                }
                if (SceneMetrics.ActiveMusicBox == 86)
                {
                    newMusic = 90;
                }
                if (SceneMetrics.ActiveMusicBox == 87)
                {
                    newMusic = 91;
                }
            }
            if (gameMenu || musicVolume == 0f)
            {
                musicBox2 = -1;
                SceneMetrics.ActiveMusicBox = -1;
            }
            if (musicVolume == 0f)
            {
                newMusic = 0;
            }
            audioSystem.Update();
            audioSystem.UpdateMisc();
            curMusic = newMusic;
            float num = 1f;
            if (NPC.MoonLordCountdown > 0)
            {
                num = (float)NPC.MoonLordCountdown / (float)NPC.MaxMoonLordCountdown;
                num *= num;
                if ((float)NPC.MoonLordCountdown > (float)NPC.MaxMoonLordCountdown * 0.2f)
                {
                    num = MathHelper.Lerp(0f, 1f, num);
                }
                else
                {
                    num = 0f;
                    curMusic = 0;
                }
                if (NPC.MoonLordCountdown == 1 && curMusic >= 1 && curMusic < maxMusic)
                {
                    musicFade[curMusic] = 0f;
                }
            }
            bool isMainTrackAudible = musicFade[curMusic] > 0.25f;
            for (int i = 1; i < maxMusic; i++)
            {
                float num2 = musicFade[i] * musicVolume * num;
                if (i >= 62 && i <= 88)
                {
                    num2 *= 0.9f;
                }
                else if (i == 52)
                {
                    num2 *= 1.15f;
                    if (num2 > 1f)
                    {
                        num2 = 1f;
                    }
                }
                float num3 = shimmerAlpha;
                switch (i)
                {
                case 28:
                {
                    float num7 = 0.5f;
                    float num8 = cloudAlpha / 9f * 10f * num7 + (1f - num7);
                    if (num3 > 0f)
                    {
                        num8 *= 1f - num3;
                    }
                    if (num8 > 1f)
                    {
                        num8 = 1f;
                    }
                    if (gameMenu)
                    {
                        num8 = 0f;
                    }
                    num8 *= (float)Math.Pow(atmo, 4.0);
                    if (remixWorld)
                    {
                        if (cloudAlpha > 0f && (double)(player[myPlayer].position.Y / 16f) > rockLayer && player[myPlayer].position.Y / 16f < (float)(maxTilesY - 350) && !player[myPlayer].ZoneSnow && !player[myPlayer].ZoneDungeon)
                        {
                            float trackVolume5 = musicFade[i];
                            audioSystem.UpdateAmbientCueState(i, flag, ref trackVolume5, ambientVolume * num8);
                            musicFade[i] = trackVolume5;
                        }
                        else
                        {
                            float trackVolume6 = musicFade[i];
                            audioSystem.UpdateAmbientCueTowardStopping(i, 0.005f, ref trackVolume6, ambientVolume * num8);
                            musicFade[i] = trackVolume6;
                        }
                    }
                    else if (cloudAlpha > 0f && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2) && !player[myPlayer].ZoneSnow)
                    {
                        float trackVolume7 = musicFade[i];
                        audioSystem.UpdateAmbientCueState(i, flag, ref trackVolume7, ambientVolume * num8);
                        musicFade[i] = trackVolume7;
                    }
                    else
                    {
                        float trackVolume8 = musicFade[i];
                        audioSystem.UpdateAmbientCueTowardStopping(i, 0.005f, ref trackVolume8, ambientVolume * num8);
                        musicFade[i] = trackVolume8;
                    }
                    break;
                }
                case 45:
                {
                    float num4 = 0.7f;
                    float num5 = Math.Abs(windSpeedCurrent) * num4 + (1f - num4);
                    if (num3 > 0f)
                    {
                        num5 *= 1f - num3;
                    }
                    if (num5 > 1f)
                    {
                        num5 = 1f;
                    }
                    num5 *= 0.9f;
                    float num6 = 20f;
                    num5 *= (float)Math.Pow(atmo, 4.0);
                    if (remixWorld)
                    {
                        if (!gameMenu && Math.Abs(windSpeedCurrent) >= num6 / 50f && (double)(player[myPlayer].position.Y / 16f) > rockLayer && player[myPlayer].position.Y / 16f < (float)(maxTilesY - 350) && !player[myPlayer].ZoneDungeon)
                        {
                            float trackVolume = musicFade[i];
                            audioSystem.UpdateAmbientCueState(i, flag, ref trackVolume, ambientVolume * num5);
                            musicFade[i] = trackVolume;
                        }
                        else
                        {
                            float trackVolume2 = musicFade[i];
                            audioSystem.UpdateAmbientCueTowardStopping(i, 0.005f, ref trackVolume2, ambientVolume * num5);
                            musicFade[i] = trackVolume2;
                        }
                    }
                    else if (!gameMenu && Math.Abs(windSpeedCurrent) >= num6 / 50f && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
                    {
                        float trackVolume3 = musicFade[i];
                        audioSystem.UpdateAmbientCueState(i, flag, ref trackVolume3, ambientVolume * num5);
                        musicFade[i] = trackVolume3;
                    }
                    else
                    {
                        float trackVolume4 = musicFade[i];
                        audioSystem.UpdateAmbientCueTowardStopping(i, 0.005f, ref trackVolume4, ambientVolume * num5);
                        musicFade[i] = trackVolume4;
                    }
                    break;
                }
                default:
                {
                    float tempFade = musicFade[i];
                    if (i == curMusic)
                    {
                        audioSystem.UpdateCommonTrack(flag, i, num2, ref tempFade);
                    }
                    else
                    {
                        audioSystem.UpdateCommonTrackTowardStopping(i, num2, ref tempFade, isMainTrackAudible);
                    }
                    musicFade[i] = tempFade;
                    break;
                }
                }
            }
            audioSystem.UpdateAudioEngine();
            if (musicError > 0)
            {
                musicError--;
            }
        }
        catch
        {
            musicError++;
            if (musicError >= 100)
            {
                musicError = 0;
                musicVolume = 0f;
            }
        }
    }
 
    private void UpdateAudio_DecideOnTOWMusic()
    {
        bool flag = false;
        bool flag2 = false;
        bool flag3 = false;
        bool flag4 = false;
        bool flag5 = false;
        bool flag6 = false;
        bool flag7 = false;
        bool flag8 = false;
        bool flag9 = false;
        bool flag10 = false;
        bool flag11 = false;
        bool flag12 = false;
        bool flag13 = false;
        bool flag14 = false;
        bool flag15 = false;
        bool flag16 = false;
        bool flag17 = false;
        if (!showSplash)
        {
            Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X, (int)screenPosition.Y, screenWidth, screenHeight);
            int num = 5000;
            for (int i = 0; i < 200; i++)
            {
                if (!npc[i].active)
                {
                    continue;
                }
                num = 5000;
                int num2 = 0;
                switch (npc[i].type)
                {
                case 13:
                case 14:
                case 15:
                    num2 = 1;
                    break;
                case 26:
                case 27:
                case 28:
                case 29:
                case 111:
                case 471:
                    num2 = 11;
                    break;
                case 113:
                case 114:
                    num2 = 3;
                    break;
                case 125:
                case 126:
                    num2 = 2;
                    break;
                case 127:
                case 134:
                    num2 = 2;
                    break;
                case 143:
                case 144:
                case 145:
                    num2 = 11;
                    break;
                case 266:
                    num2 = 1;
                    break;
                case 212:
                case 213:
                case 214:
                case 215:
                case 216:
                case 491:
                    num2 = 8;
                    break;
                case 245:
                    num2 = 2;
                    break;
                case 222:
                    num2 = 1;
                    break;
                case 262:
                case 263:
                case 264:
                    num2 = 6;
                    break;
                case 381:
                case 382:
                case 383:
                case 385:
                case 386:
                case 388:
                case 389:
                case 390:
                case 391:
                case 395:
                case 520:
                    num2 = 9;
                    break;
                case 398:
                    num2 = 7;
                    break;
                case 422:
                case 493:
                case 507:
                case 517:
                    num2 = 10;
                    break;
                case 439:
                    num2 = 2;
                    break;
                case 438:
                    if (npc[i].ai[1] == 1f)
                    {
                        num = 1600;
                        num2 = 2;
                    }
                    break;
                case 657:
                    num2 = 13;
                    break;
                case 636:
                    num2 = 14;
                    break;
                case 370:
                    num2 = 15;
                    break;
                case 668:
                    num2 = 16;
                    break;
                }
                if (NPCID.Sets.BelongsToInvasionOldOnesArmy[npc[i].type])
                {
                    num2 = 12;
                }
                if (remixWorld && getGoodWorld && (npc[i].type == 127 || npc[i].type == 134 || npc[i].type == 125 || npc[i].type == 126))
                {
                    num2 = 17;
                }
                if (num2 == 0 && npc[i].boss)
                {
                    num2 = 1;
                }
                if (num2 == 0)
                {
                    continue;
                }
                Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle((int)(npc[i].position.X + (float)(npc[i].width / 2)) - num, (int)(npc[i].position.Y + (float)(npc[i].height / 2)) - num, num * 2, num * 2);
                if (rectangle.Intersects(value))
                {
                    switch (num2)
                    {
                    case 1:
                        flag = true;
                        break;
                    case 2:
                        flag3 = true;
                        break;
                    case 3:
                        flag4 = true;
                        break;
                    case 4:
                        flag5 = true;
                        break;
                    case 5:
                        flag6 = true;
                        break;
                    case 6:
                        flag7 = true;
                        break;
                    case 7:
                        flag8 = true;
                        break;
                    case 8:
                        flag9 = true;
                        break;
                    case 9:
                        flag10 = true;
                        break;
                    case 10:
                        flag11 = true;
                        break;
                    case 11:
                        flag12 = true;
                        break;
                    case 12:
                        flag13 = true;
                        break;
                    case 13:
                        flag14 = true;
                        break;
                    case 14:
                        flag15 = true;
                        break;
                    case 15:
                        flag16 = true;
                        break;
                    case 16:
                        flag2 = true;
                        break;
                    case 17:
                        flag17 = true;
                        break;
                    }
                    break;
                }
            }
        }
        _ = (screenPosition.X + (float)(screenWidth / 2)) / 16f;
        if (musicVolume == 0f)
        {
            newMusic = 0;
            return;
        }
        float num3 = (float)maxTilesX / 4200f;
        num3 *= num3;
        float num4 = (float)((double)((screenPosition.Y + (float)(screenHeight / 2)) / 16f - (65f + 10f * num3)) / (worldSurface / 5.0));
        if (CreditsRollEvent.IsEventOngoing)
        {
            newMusic = 89;
        }
        else if (player[myPlayer].happyFunTorchTime)
        {
            newMusic = 87;
        }
        else if (flag8)
        {
            newMusic = 84;
        }
        else if (flag17)
        {
            newMusic = 81;
        }
        else if (flag10)
        {
            newMusic = 82;
        }
        else if (flag11)
        {
            newMusic = 83;
        }
        else if (flag7)
        {
            newMusic = 85;
        }
        else if (flag15)
        {
            newMusic = 80;
        }
        else if (flag16)
        {
            newMusic = 80;
        }
        else if (flag3)
        {
            newMusic = 80;
        }
        else if (flag)
        {
            newMusic = 81;
        }
        else if (flag4)
        {
            newMusic = 87;
        }
        else if (flag5)
        {
            newMusic = 81;
        }
        else if (flag6)
        {
            newMusic = 81;
        }
        else if (flag14)
        {
            newMusic = 80;
        }
        else if (flag2)
        {
            newMusic = 80;
        }
        else if (flag9)
        {
            newMusic = 82;
        }
        else if (flag12)
        {
            newMusic = 82;
        }
        else if (flag13)
        {
            newMusic = 82;
        }
        else if (eclipse && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
        {
            newMusic = 79;
        }
        else if (eclipse && remixWorld)
        {
            newMusic = 79;
        }
        else if (remixWorld && bloodMoon && !player[myPlayer].ZoneCrimson && !player[myPlayer].ZoneCorrupt && (double)player[myPlayer].position.Y > rockLayer * 16.0 && player[myPlayer].position.Y <= (float)(UnderworldLayer * 16))
        {
            newMusic = 79;
        }
        else if (remixWorld && bloodMoon && player[myPlayer].position.Y > (float)(UnderworldLayer * 16) && (double)(player[myPlayer].Center.X / 16f) > (double)maxTilesX * 0.37 + 50.0 && (double)(player[myPlayer].Center.X / 16f) < (double)maxTilesX * 0.63)
        {
            newMusic = 79;
        }
        else if (player[myPlayer].ZoneShimmer)
        {
            newMusic = 72;
        }
        else if (player[myPlayer].ZoneSandstorm)
        {
            newMusic = 66;
        }
        else if (player[myPlayer].position.Y > (float)(UnderworldLayer * 16))
        {
            newMusic = 71;
        }
        else if (num4 < 1f)
        {
            newMusic = 70;
        }
        else if (tile[(int)(player[myPlayer].Center.X / 16f), (int)(player[myPlayer].Center.Y / 16f)].wall == 87)
        {
            newMusic = 69;
        }
        else if (player[myPlayer].ZoneDungeon)
        {
            newMusic = 69;
        }
        else if ((bgStyle == 9 && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2)) || undergroundBackground == 2)
        {
            newMusic = 68;
        }
        else if (player[myPlayer].ZoneCorrupt)
        {
            if (player[myPlayer].ZoneCrimson && SceneMetrics.BloodTileCount > SceneMetrics.EvilTileCount)
            {
                if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 76;
                }
                else
                {
                    newMusic = 75;
                }
            }
            else if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 74;
            }
            else
            {
                newMusic = 73;
            }
        }
        else if (player[myPlayer].ZoneCrimson)
        {
            if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 76;
            }
            else
            {
                newMusic = 75;
            }
        }
        else if (player[myPlayer].ZoneMeteor)
        {
            newMusic = 79;
        }
        else if (player[myPlayer].ZoneGraveyard)
        {
            newMusic = 79;
        }
        else if (player[myPlayer].ZoneJungle)
        {
            if (remixWorld && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 70;
            }
            else
            {
                newMusic = 86;
            }
        }
        else if (player[myPlayer].ZoneSnow)
        {
            if (remixWorld)
            {
                if ((double)player[myPlayer].position.Y < rockLayer * 16.0 + (double)(screenHeight / 2))
                {
                    if ((double)player[myPlayer].position.Y <= worldSurface * 16.0 + (double)(screenHeight / 2))
                    {
                        newMusic = 70;
                    }
                    else
                    {
                        newMusic = 77;
                    }
                }
                else
                {
                    newMusic = 72;
                }
            }
            else if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 77;
            }
            else
            {
                newMusic = 72;
            }
        }
        else if ((double)player[myPlayer].position.Y >= worldSurface * 16.0 + (double)(screenHeight / 2) && !WorldGen.oceanDepths((int)(screenPosition.X + (float)(screenWidth / 2)) / 16, (int)(screenPosition.Y + (float)(screenHeight / 2)) / 16))
        {
            if (remixWorld && (double)player[myPlayer].position.Y >= rockLayer * 16.0 + (double)(screenHeight / 2))
            {
                if (player[myPlayer].ZoneUndergroundDesert)
                {
                    newMusic = 66;
                }
                else if (cloudAlpha > 0f)
                {
                    newMusic = 62;
                }
                else if (player[myPlayer].ZoneHallow)
                {
                    newMusic = 88;
                }
                else if (player[myPlayer].ZoneDesert)
                {
                    newMusic = 66;
                }
                else
                {
                    newMusic = 62;
                }
            }
            else if (player[myPlayer].ZoneHallow)
            {
                newMusic = 78;
            }
            else if (player[myPlayer].ZoneUndergroundDesert)
            {
                newMusic = 66;
            }
            else
            {
                newMusic = 65;
            }
        }
        else if (dayTime && player[myPlayer].ZoneHallow)
        {
            if (cloudAlpha > 0f && !gameMenu)
            {
                newMusic = 62;
            }
            else
            {
                newMusic = 88;
            }
        }
        else if (_shouldUseStormMusic)
        {
            if (bloodMoon)
            {
                newMusic = 79;
            }
            else
            {
                newMusic = 62;
            }
        }
        else if (WorldGen.oceanDepths((int)(screenPosition.X + (float)(screenWidth / 2)) / 16, (int)(screenPosition.Y + (float)(screenHeight / 2)) / 16))
        {
            if (bloodMoon)
            {
                newMusic = 79;
            }
            else
            {
                newMusic = 67;
            }
        }
        else if (player[myPlayer].ZoneDesert)
        {
            newMusic = 66;
        }
        else if (remixWorld)
        {
            newMusic = 70;
        }
        else if (dayTime)
        {
            if (cloudAlpha > 0f && !gameMenu)
            {
                newMusic = 62;
            }
            else
            {
                newMusic = 63;
            }
        }
        else if (!dayTime)
        {
            if (bloodMoon)
            {
                newMusic = 79;
            }
            else if (cloudAlpha > 0f && !gameMenu)
            {
                newMusic = 64;
            }
            else
            {
                newMusic = 64;
            }
        }
        if (((double)(screenPosition.Y / 16f) < worldSurface + 10.0 || remixWorld) && pumpkinMoon)
        {
            newMusic = 82;
        }
        if (((double)(screenPosition.Y / 16f) < worldSurface + 10.0 || remixWorld) && snowMoon)
        {
            newMusic = 82;
        }
    }
 
    private void UpdateAudio_DecideOnNewMusic()
    {
        bool flag = false;
        bool flag2 = false;
        bool flag3 = false;
        bool flag4 = false;
        bool flag5 = false;
        bool flag6 = false;
        bool flag7 = false;
        bool flag8 = false;
        bool flag9 = false;
        bool flag10 = false;
        bool flag11 = false;
        bool flag12 = false;
        bool flag13 = false;
        bool flag14 = false;
        bool flag15 = false;
        bool flag16 = false;
        bool flag17 = false;
        bool flag18 = LocalPlayer.townNPCs > 2f;
        bool flag19 = slimeRain;
        if (SceneMetrics.ShadowCandleCount > 0 || LocalPlayer.inventory[LocalPlayer.selectedItem].type == 5322)
        {
            flag18 = false;
        }
        float num = 0f;
        for (int i = 0; i < maxMusic; i++)
        {
            if (musicFade[i] > num)
            {
                num = musicFade[i];
                if (num == 1f)
                {
                    lastMusicPlayed = i;
                }
            }
        }
        if (lastMusicPlayed == 50)
        {
            musicNoCrossFade[51] = true;
        }
        if (!showSplash)
        {
            Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X, (int)screenPosition.Y, screenWidth, screenHeight);
            int num2 = 5000;
            for (int j = 0; j < 200; j++)
            {
                if (!npc[j].active)
                {
                    continue;
                }
                num2 = 5000;
                int num3 = 0;
                switch (npc[j].type)
                {
                case 13:
                case 14:
                case 15:
                case 127:
                case 128:
                case 129:
                case 130:
                case 131:
                    num3 = 1;
                    break;
                case 26:
                case 27:
                case 28:
                case 29:
                case 111:
                case 471:
                    num3 = 11;
                    break;
                case 113:
                case 114:
                case 125:
                case 126:
                    num3 = 2;
                    break;
                case 134:
                case 135:
                case 136:
                case 143:
                case 144:
                case 145:
                case 266:
                    num3 = 3;
                    break;
                case 212:
                case 213:
                case 214:
                case 215:
                case 216:
                case 491:
                    num3 = 8;
                    break;
                case 245:
                    num3 = 4;
                    break;
                case 222:
                    num3 = 5;
                    break;
                case 262:
                case 263:
                case 264:
                    num3 = 6;
                    break;
                case 381:
                case 382:
                case 383:
                case 385:
                case 386:
                case 388:
                case 389:
                case 390:
                case 391:
                case 395:
                case 520:
                    num3 = 9;
                    break;
                case 398:
                    num3 = 7;
                    break;
                case 422:
                case 493:
                case 507:
                case 517:
                    num3 = 10;
                    break;
                case 439:
                    num3 = 4;
                    break;
                case 438:
                    if (npc[j].ai[1] == 1f)
                    {
                        num2 = 1600;
                        num3 = 4;
                    }
                    break;
                case 657:
                    num3 = 13;
                    break;
                case 636:
                    num3 = 14;
                    break;
                case 370:
                    num3 = 15;
                    break;
                case 668:
                    num3 = 16;
                    break;
                }
                if (NPCID.Sets.BelongsToInvasionOldOnesArmy[npc[j].type])
                {
                    num3 = 12;
                }
                if (num3 == 0 && npc[j].boss)
                {
                    num3 = 1;
                }
                if (remixWorld && getGoodWorld && (npc[j].type == 127 || npc[j].type == 134 || npc[j].type == 125 || npc[j].type == 126))
                {
                    num3 = 17;
                }
                if (num3 == 0)
                {
                    continue;
                }
                Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle((int)(npc[j].position.X + (float)(npc[j].width / 2)) - num2, (int)(npc[j].position.Y + (float)(npc[j].height / 2)) - num2, num2 * 2, num2 * 2);
                if (rectangle.Intersects(value))
                {
                    switch (num3)
                    {
                    case 1:
                        flag = true;
                        break;
                    case 2:
                        flag3 = true;
                        break;
                    case 3:
                        flag4 = true;
                        break;
                    case 4:
                        flag5 = true;
                        break;
                    case 5:
                        flag6 = true;
                        break;
                    case 6:
                        flag7 = true;
                        break;
                    case 7:
                        flag8 = true;
                        break;
                    case 8:
                        flag9 = true;
                        break;
                    case 9:
                        flag10 = true;
                        break;
                    case 10:
                        flag11 = true;
                        break;
                    case 11:
                        flag12 = true;
                        break;
                    case 12:
                        flag13 = true;
                        break;
                    case 13:
                        flag14 = true;
                        break;
                    case 14:
                        flag15 = true;
                        break;
                    case 15:
                        flag16 = true;
                        break;
                    case 16:
                        flag2 = true;
                        break;
                    case 17:
                        flag17 = true;
                        break;
                    }
                    break;
                }
            }
        }
        _ = (screenPosition.X + (float)(screenWidth / 2)) / 16f;
        if (musicVolume == 0f)
        {
            newMusic = 0;
            return;
        }
        if (gameMenu)
        {
            if (netMode != 2)
            {
                if (WorldGen.drunkWorldGen)
                {
                    if (WorldGen.remixWorldGen)
                    {
                        newMusic = 70;
                    }
                    else
                    {
                        newMusic = 60;
                    }
                }
                else if (WorldGen.remixWorldGen)
                {
                    newMusic = 8;
                }
                else if (menuMode == 3000)
                {
                    newMusic = 89;
                }
                else if (WorldGen.tenthAnniversaryWorldGen)
                {
                    newMusic = 11;
                }
                else if (playOldTile)
                {
                    newMusic = 6;
                }
                else if (!_isAsyncLoadComplete)
                {
                    newMusic = 50;
                }
                else if (!audioSystem.IsTrackPlaying(50))
                {
                    newMusic = 51;
                    if (musicNoCrossFade[51])
                    {
                        musicFade[51] = 1f;
                    }
                }
            }
            else
            {
                newMusic = 0;
            }
            return;
        }
        float num4 = (float)maxTilesX / 4200f;
        num4 *= num4;
        float num5 = (float)((double)((screenPosition.Y + (float)(screenHeight / 2)) / 16f - (65f + 10f * num4)) / (worldSurface / 5.0));
        if (CreditsRollEvent.IsEventOngoing)
        {
            newMusic = 89;
        }
        else if (player[myPlayer].happyFunTorchTime)
        {
            newMusic = 13;
        }
        else if (flag8)
        {
            newMusic = 38;
        }
        else if (flag17)
        {
            newMusic = 81;
        }
        else if (flag10)
        {
            newMusic = 37;
        }
        else if (flag11)
        {
            newMusic = 34;
        }
        else if (flag7)
        {
            newMusic = 24;
        }
        else if (flag15)
        {
            newMusic = 57;
        }
        else if (flag16)
        {
            newMusic = 58;
        }
        else if (flag3)
        {
            newMusic = 12;
        }
        else if (flag)
        {
            newMusic = 5;
        }
        else if (flag4)
        {
            newMusic = 13;
        }
        else if (flag5)
        {
            newMusic = 17;
        }
        else if (flag6)
        {
            newMusic = 25;
        }
        else if (flag14)
        {
            newMusic = 56;
        }
        else if (flag2)
        {
            newMusic = 90;
        }
        else if (flag9)
        {
            newMusic = 35;
        }
        else if (flag12)
        {
            newMusic = 39;
        }
        else if (flag13)
        {
            newMusic = 41;
        }
        else if (eclipse && !remixWorld && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
        {
            newMusic = 27;
        }
        else if (eclipse && remixWorld && (double)player[myPlayer].position.Y > rockLayer * 16.0)
        {
            newMusic = 27;
        }
        else if (flag19 && !player[myPlayer].ZoneGraveyard && (!bloodMoon || dayTime) && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
        {
            newMusic = 48;
        }
        else if (remixWorld && bloodMoon && !player[myPlayer].ZoneCrimson && !player[myPlayer].ZoneCorrupt && (double)player[myPlayer].position.Y > rockLayer * 16.0 && player[myPlayer].position.Y <= (float)(UnderworldLayer * 16))
        {
            newMusic = 2;
        }
        else if (remixWorld && bloodMoon && player[myPlayer].position.Y > (float)(UnderworldLayer * 16) && (double)(player[myPlayer].Center.X / 16f) > (double)maxTilesX * 0.37 + 50.0 && (double)(player[myPlayer].Center.X / 16f) < (double)maxTilesX * 0.63)
        {
            newMusic = 2;
        }
        else if (player[myPlayer].ZoneShimmer)
        {
            newMusic = 91;
        }
        else if (flag18 && dayTime && ((cloudAlpha == 0f && !_shouldUseWindyDayMusic) || (double)player[myPlayer].position.Y >= worldSurface * 16.0 + (double)(screenHeight / 2)) && !player[myPlayer].ZoneGraveyard)
        {
            newMusic = 46;
        }
        else if (flag18 && !dayTime && ((!bloodMoon && cloudAlpha == 0f) || (double)player[myPlayer].position.Y >= worldSurface * 16.0 + (double)(screenHeight / 2)) && !player[myPlayer].ZoneGraveyard)
        {
            newMusic = 47;
        }
        else if (player[myPlayer].ZoneSandstorm)
        {
            newMusic = 40;
        }
        else if (player[myPlayer].position.Y > (float)(UnderworldLayer * 16))
        {
            newMusic = 36;
        }
        else if (num5 < 1f)
        {
            newMusic = (dayTime ? 42 : 15);
        }
        else if (tile[(int)(player[myPlayer].Center.X / 16f), (int)(player[myPlayer].Center.Y / 16f)].wall == 87)
        {
            newMusic = 26;
        }
        else if (player[myPlayer].ZoneDungeon)
        {
            newMusic = 23;
        }
        else if ((bgStyle == 9 && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2)) || undergroundBackground == 2)
        {
            newMusic = 29;
        }
        else if (player[myPlayer].ZoneCorrupt)
        {
            if (player[myPlayer].ZoneCrimson && SceneMetrics.BloodTileCount > SceneMetrics.EvilTileCount)
            {
                if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 33;
                }
                else
                {
                    newMusic = 16;
                }
            }
            else if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 10;
            }
            else
            {
                newMusic = 8;
            }
        }
        else if (player[myPlayer].ZoneCrimson)
        {
            if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 33;
            }
            else
            {
                newMusic = 16;
            }
        }
        else if (player[myPlayer].ZoneMeteor)
        {
            newMusic = 2;
        }
        else if (player[myPlayer].ZoneGraveyard)
        {
            newMusic = 53;
        }
        else if (player[myPlayer].ZoneJungle)
        {
            if (remixWorld)
            {
                if ((double)player[myPlayer].position.Y > rockLayer * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 7;
                }
                else if (newMusic == 7 && (double)player[myPlayer].position.Y > (rockLayer - 50.0) * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 7;
                }
                else if ((double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = (dayTime ? 42 : 15);
                }
                else
                {
                    newMusic = 54;
                }
            }
            else if ((double)player[myPlayer].position.Y > rockLayer * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 54;
            }
            else if (newMusic == 54 && (double)player[myPlayer].position.Y > (rockLayer - 50.0) * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 54;
            }
            else if (_shouldUseStormMusic && (double)player[myPlayer].position.Y < worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                newMusic = 52;
            }
            else if (dayTime)
            {
                newMusic = 7;
            }
            else
            {
                newMusic = 55;
            }
        }
        else if (player[myPlayer].ZoneSnow)
        {
            if ((double)player[myPlayer].position.Y > worldSurface * 16.0 + (double)(screenHeight / 2))
            {
                if (remixWorld && (double)player[myPlayer].position.Y > rockLayer * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 14;
                }
                else
                {
                    newMusic = 20;
                }
            }
            else if (remixWorld)
            {
                newMusic = (dayTime ? 42 : 15);
            }
            else
            {
                newMusic = 14;
            }
        }
        else if ((double)player[myPlayer].position.Y >= worldSurface * 16.0 + (double)(screenHeight / 2) && (remixWorld || !WorldGen.oceanDepths((int)(screenPosition.X + (float)(screenWidth / 2)) / 16, (int)(screenPosition.Y + (float)(screenHeight / 2)) / 16)))
        {
            if (player[myPlayer].ZoneHallow)
            {
                if (remixWorld && (double)player[myPlayer].position.Y >= rockLayer * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 9;
                }
                else
                {
                    newMusic = 11;
                }
            }
            else if (player[myPlayer].ZoneUndergroundDesert)
            {
                if ((double)player[myPlayer].position.Y >= worldSurface * 16.0 + (double)(screenHeight / 2))
                {
                    newMusic = 61;
                }
                else
                {
                    newMusic = 21;
                }
            }
            else
            {
                if (ugMusic == 0)
                {
                    ugMusic = 4;
                }
                if (!audioSystem.IsTrackPlaying(4) && !audioSystem.IsTrackPlaying(31))
                {
                    if (musicFade[4] == 1f)
                    {
                        musicFade[31] = 1f;
                    }
                    if (musicFade[31] == 1f)
                    {
                        musicFade[4] = 1f;
                    }
                    switch (rand.Next(2))
                    {
                    case 0:
                        ugMusic = 4;
                        musicFade[31] = 0f;
                        break;
                    case 1:
                        ugMusic = 31;
                        musicFade[4] = 0f;
                        break;
                    }
                }
                newMusic = ugMusic;
                if (remixWorld && (double)(player[myPlayer].position.Y / 16f) > rockLayer && player[myPlayer].position.Y / 16f < (float)(maxTilesY - 350))
                {
                    if (cloudAlpha > 0f)
                    {
                        newMusic = 19;
                    }
                    else if (player[myPlayer].ZoneDesert)
                    {
                        newMusic = 21;
                    }
                    else if (_shouldUseWindyDayMusic)
                    {
                        newMusic = 44;
                    }
                }
            }
        }
        else if (dayTime && player[myPlayer].ZoneHallow)
        {
            if (_shouldUseStormMusic)
            {
                newMusic = 52;
            }
            else if (cloudAlpha > 0f && !gameMenu)
            {
                newMusic = 19;
            }
            else if (_shouldUseWindyDayMusic && !remixWorld)
            {
                newMusic = 44;
            }
            else
            {
                newMusic = 9;
            }
        }
        else if (_shouldUseStormMusic)
        {
            if (bloodMoon)
            {
                newMusic = 2;
            }
            else
            {
                newMusic = 52;
            }
        }
        else if (WorldGen.oceanDepths((int)(screenPosition.X + (float)(screenWidth / 2)) / 16, (int)(screenPosition.Y + (float)(screenHeight / 2)) / 16))
        {
            if (bloodMoon)
            {
                newMusic = 2;
            }
            else if (flag18)
            {
                if (dayTime)
                {
                    newMusic = 46;
                }
                else
                {
                    newMusic = 47;
                }
            }
            else
            {
                newMusic = (dayTime ? 22 : 43);
            }
        }
        else if (player[myPlayer].ZoneDesert)
        {
            if ((double)player[myPlayer].position.Y >= worldSurface * 16.0)
            {
                int num6 = (int)(player[myPlayer].Center.X / 16f);
                int num7 = (int)(player[myPlayer].Center.Y / 16f);
                if (WorldGen.InWorld(num6, num7) && (WallID.Sets.Conversion.Sandstone[tile[num6, num7].wall] || WallID.Sets.Conversion.HardenedSand[tile[num6, num7].wall]))
                {
                    newMusic = 61;
                }
                else
                {
                    newMusic = 21;
                }
            }
            else
            {
                newMusic = 21;
            }
        }
        else if (remixWorld)
        {
            newMusic = (dayTime ? 42 : 15);
        }
        else if (dayTime)
        {
            if (cloudAlpha > 0f && !gameMenu)
            {
                if (time < 10800.0)
                {
                    newMusic = 59;
                }
                else
                {
                    newMusic = 19;
                }
            }
            else
            {
                if (dayMusic == 0)
                {
                    dayMusic = 1;
                }
                if (!audioSystem.IsTrackPlaying(1) && !audioSystem.IsTrackPlaying(18))
                {
                    if (rand.Next(2) == 0)
                    {
                        dayMusic = 1;
                    }
                    else
                    {
                        dayMusic = 18;
                    }
                }
                newMusic = dayMusic;
                if (_shouldUseWindyDayMusic && !remixWorld)
                {
                    newMusic = 44;
                }
            }
        }
        else if (!dayTime)
        {
            if (bloodMoon)
            {
                newMusic = 2;
            }
            else if (cloudAlpha > 0f && !gameMenu)
            {
                newMusic = 19;
            }
            else
            {
                newMusic = 3;
            }
        }
        if (((double)(screenPosition.Y / 16f) < worldSurface + 10.0 || remixWorld) && pumpkinMoon)
        {
            newMusic = 30;
        }
        if (((double)(screenPosition.Y / 16f) < worldSurface + 10.0 || remixWorld) && snowMoon)
        {
            newMusic = 32;
        }
    }
 
    private void UpdateWindyDayState()
    {
        if (cloudAlpha == 0f)
        {
            _shouldUseStormMusic = false;
            if (time < 10800.0 || time > 43200.0 || !dayTime)
            {
                _shouldUseWindyDayMusic = false;
                return;
            }
            if (Math.Abs(windSpeedTarget) < _minWind)
            {
                _shouldUseWindyDayMusic = false;
            }
            if (Math.Abs(windSpeedTarget) >= _maxWind)
            {
                _shouldUseWindyDayMusic = true;
            }
        }
        else
        {
            if (cloudAlpha < _minRain || Math.Abs(windSpeedTarget) < _minWind)
            {
                _shouldUseStormMusic = false;
            }
            else if (cloudAlpha >= _maxRain && Math.Abs(windSpeedTarget) >= _maxWind)
            {
                _shouldUseStormMusic = true;
            }
            if (remixWorld)
            {
                _shouldUseStormMusic = false;
            }
            else
            {
                _shouldUseWindyDayMusic = false;
            }
        }
    }
 
    public static void snowing()
    {
        if (remixWorld)
        {
            return;
        }
        Vector2 scaledSize = Camera.ScaledSize;
        Vector2 scaledPosition = Camera.ScaledPosition;
        if (gamePaused || SceneMetrics.SnowTileCount <= 0 || (!((double)player[myPlayer].position.Y < worldSurface * 16.0) && (!remixWorld || !((double)player[myPlayer].position.Y > worldSurface * 16.0))))
        {
            return;
        }
        float num = (float)SceneMetrics.SnowTileCount / (float)SceneMetrics.SnowTileMax;
        num *= num;
        num *= num;
        float num2 = Camera.ScaledSize.X / (float)maxScreenW;
        int num3 = (int)(500f * num2);
        num3 = (int)((float)num3 * (1f + 2f * cloudAlpha));
        float num4 = 1f + 50f * cloudAlpha;
        bool flag = NPC.IsADeerclopsNearScreen();
        if (flag)
        {
            num /= 20f;
            num3 /= 3;
        }
        for (int i = 0; (float)i < num4; i++)
        {
            try
            {
                if (!((float)snowDust < (float)num3 * (gfxQuality / 2f + 0.5f) + (float)num3 * 0.1f))
                {
                    break;
                }
                if (!(rand.NextFloat() < num))
                {
                    continue;
                }
                int num5 = rand.Next((int)scaledSize.X + 1500) - 750;
                int num6 = (int)scaledPosition.Y - rand.Next(50);
                if (player[myPlayer].velocity.Y > 0f)
                {
                    num6 -= (int)player[myPlayer].velocity.Y;
                }
                if (rand.Next(5) == 0)
                {
                    num5 = rand.Next(500) - 500;
                }
                else if (rand.Next(5) == 0)
                {
                    num5 = rand.Next(500) + (int)scaledSize.X;
                }
                if (num5 < 0 || (float)num5 > scaledSize.X)
                {
                    num6 += rand.Next((int)((double)scaledSize.Y * 0.8)) + (int)((double)scaledSize.Y * 0.1);
                }
                num5 += (int)scaledPosition.X;
                int num7 = num5 / 16;
                int num8 = num6 / 16;
                if (WorldGen.InWorld(num7, num8) && tile[num7, num8] != null && !tile[num7, num8].nactive() && tile[num7, num8].wall == 0)
                {
                    int num9 = Dust.NewDust(new Vector2(num5, num6), 10, 10, 76);
                    dust[num9].scale += cloudAlpha * 0.2f;
                    dust[num9].velocity.Y = 3f + (float)rand.Next(30) * 0.1f;
                    dust[num9].velocity.Y *= dust[num9].scale;
                    if (!raining)
                    {
                        dust[num9].velocity.X = windSpeedCurrent + (float)rand.Next(-10, 10) * 0.1f;
                        dust[num9].velocity.X += windSpeedCurrent * 15f;
                    }
                    else
                    {
                        dust[num9].velocity.X = (float)Math.Sqrt(Math.Abs(windSpeedCurrent)) * (float)Math.Sign(windSpeedCurrent) * (cloudAlpha + 0.5f) * 10f + rand.NextFloat() * 0.2f - 0.1f;
                        dust[num9].velocity.Y *= 0.5f;
                    }
                    dust[num9].velocity.Y *= 1f + 0.3f * cloudAlpha;
                    dust[num9].scale += cloudAlpha * 0.2f;
                    if (flag)
                    {
                        dust[num9].scale -= 0.5f;
                    }
                    dust[num9].velocity *= 1f + cloudAlpha * 0.5f;
                }
                continue;
            }
            catch
            {
            }
        }
    }
 
    public static void checkXMas()
    {
        DateTime now = DateTime.Now;
        int day = now.Day;
        int month = now.Month;
        if (day >= 15 && month == 12)
        {
            xMas = true;
        }
        else
        {
            xMas = false;
        }
        if (forceXMasForToday)
        {
            xMas = true;
        }
    }
 
    public static void checkHalloween()
    {
        DateTime now = DateTime.Now;
        int day = now.Day;
        int month = now.Month;
        if (day >= 10 && month == 10)
        {
            halloween = true;
        }
        else if (day <= 1 && month == 11)
        {
            halloween = true;
        }
        else
        {
            halloween = false;
        }
        if (forceHalloweenForToday)
        {
            halloween = true;
        }
    }
 
    public void updateCloudLayer()
    {
        if (netMode == 1 || (netMode == 0 && gameMenu))
        {
            return;
        }
        int num = 86400;
        int num2 = num / 24;
        float num3 = Math.Max(1f, 1f + 4f * cloudAlpha);
        if (cloudBGActive > 0f)
        {
            if (cloudBGActive > 1f)
            {
                cloudBGActive -= (float)dayRate / num3;
            }
            if (cloudBGActive < 1f)
            {
                cloudBGActive = 1f;
            }
            if (cloudBGActive == 1f && rand.Next((int)((float)(num2 * 2 / Math.Max(dayRate, 1)) * num3)) == 0)
            {
                cloudBGActive = -rand.Next(num2 * 4, num * 4);
                if (netMode == 2)
                {
                    NetMessage.SendData(7);
                }
            }
            return;
        }
        if (cloudBGActive < 0f)
        {
            cloudBGActive += (float)dayRate * num3;
            if (raining)
            {
                cloudBGActive += (float)(2 * dayRate) * num3;
            }
        }
        if (cloudBGActive > 0f)
        {
            cloudBGActive = 0f;
        }
        if (cloudBGActive == 0f && rand.Next((int)((float)(num2 * 12 / ((dayRate == 0) ? 1 : dayRate)) / num3)) == 0)
        {
            cloudBGActive = rand.Next(num2 * 3, num * 2);
            if (netMode == 2)
            {
                NetMessage.SendData(7);
            }
        }
        else if (IsItStorming)
        {
            cloudBGActive = rand.Next(num2, num2 * 4);
            if (netMode == 2)
            {
                NetMessage.SendData(7);
            }
        }
    }
 
    public static void TeleportEffect(Microsoft.Xna.Framework.Rectangle effectRect, int Style, int extraInfo = 0, float dustCountMult = 1f, TeleportationSide side = TeleportationSide.Entry, Vector2 otherPosition = default(Vector2))
    {
        switch (Style)
        {
        case 0:
        {
            SoundEngine.PlaySound(SoundID.Item6, effectRect.X + effectRect.Width / 2, effectRect.Y + effectRect.Height / 2);
            int num2 = effectRect.Width * effectRect.Height / 5;
            num2 = (int)((float)num2 * dustCountMult);
            for (int j = 0; j < num2; j++)
            {
                int num3 = Dust.NewDust(new Vector2(effectRect.X, effectRect.Y), effectRect.Width, effectRect.Height, 159);
                Main.dust[num3].scale = (float)rand.Next(20, 70) * 0.01f;
                if (j < 10)
                {
                    Main.dust[num3].scale += 0.25f;
                }
                if (j < 5)
                {
                    Main.dust[num3].scale += 0.25f;
                }
            }
            break;
        }
        case 1:
        {
            SoundEngine.PlaySound(SoundID.Item8, effectRect.X + effectRect.Width / 2, effectRect.Y + effectRect.Height / 2);
            int num10 = effectRect.Width * effectRect.Height / 5;
            num10 = (int)((float)num10 * dustCountMult);
            for (int num11 = 0; num11 < num10; num11++)
            {
                int num12 = Dust.NewDust(new Vector2(effectRect.X, effectRect.Y), effectRect.Width, effectRect.Height, 164);
                Main.dust[num12].scale = (float)rand.Next(20, 70) * 0.01f;
                if (num11 < 10)
                {
                    Main.dust[num12].scale += 0.25f;
                }
                if (num11 < 5)
                {
                    Main.dust[num12].scale += 0.25f;
                }
            }
            break;
        }
        case 2:
        {
            int num15 = (int)(50f * dustCountMult);
            for (int num16 = 0; num16 < num15; num16++)
            {
                Main.dust[Dust.NewDust(new Vector2(effectRect.X, effectRect.Y), effectRect.Width, effectRect.Height, 58, 0f, 0f, 150, Microsoft.Xna.Framework.Color.GhostWhite, 1.2f)].velocity *= 0.5f;
            }
            break;
        }
        case 3:
        {
            SoundEngine.PlaySound(SoundID.Item6, effectRect.X + effectRect.Width / 2, effectRect.Y + effectRect.Height / 2);
            int num5 = (int)(50f * dustCountMult);
            for (int l = 0; l < num5; l++)
            {
                int num6 = Dust.NewDust(new Vector2(effectRect.X, effectRect.Y), effectRect.Width, effectRect.Height, 180);
                Main.dust[num6].noGravity = true;
                for (int m = 0; m < 5; m++)
                {
                    if (rand.Next(3) == 0)
                    {
                        Main.dust[num6].velocity *= 0.75f;
                    }
                }
                if (rand.Next(3) == 0)
                {
                    Main.dust[num6].velocity *= 2f;
                    Main.dust[num6].scale *= 1.2f;
                }
                if (rand.Next(3) == 0)
                {
                    Main.dust[num6].velocity *= 2f;
                    Main.dust[num6].scale *= 1.2f;
                }
                if (rand.Next(2) == 0)
                {
                    Main.dust[num6].fadeIn = (float)rand.Next(75, 100) * 0.01f;
                    Main.dust[num6].scale = (float)rand.Next(25, 75) * 0.01f;
                }
                Main.dust[num6].scale *= 0.8f;
            }
            break;
        }
        case 4:
        {
            SoundEngine.PlaySound(SoundID.Item8, effectRect.X + effectRect.Width / 2, effectRect.Y + effectRect.Height / 2);
            int num17 = effectRect.Width * effectRect.Height / 5;
            num17 = (int)((float)num17 * dustCountMult);
            for (int num18 = 0; num18 < num17; num18++)
            {
                Dust obj4 = Main.dust[Dust.NewDust(effectRect.TopLeft(), effectRect.Width, effectRect.Height, 263)];
                obj4.color = PortalHelper.GetPortalColor(extraInfo);
                obj4.noLight = true;
                obj4.noGravity = true;
                obj4.scale = 1.2f;
                obj4.fadeIn = 0.4f;
                obj4.color.A = byte.MaxValue;
            }
            break;
        }
        case 5:
        {
            Vector2 position = effectRect.TopLeft();
            int num8 = (int)(100f * dustCountMult);
            for (int num9 = 0; num9 < num8; num9++)
            {
                Dust obj3 = Dust.NewDustDirect(position, effectRect.Width, effectRect.Height + 24, Dust.dustWater());
                obj3.velocity.Y *= 0f;
                obj3.velocity.Y -= 3.5f;
                obj3.velocity.X *= 1.5f;
                obj3.scale = 0.8f;
                obj3.alpha = 130;
                obj3.noGravity = true;
                obj3.fadeIn = 1.2f;
            }
            SoundEngine.PlaySound(19, effectRect.Center.ToVector2(), 0);
            break;
        }
        case 7:
        {
            Vector2 position2 = effectRect.TopLeft();
            int num19 = (int)(50f * dustCountMult);
            for (int num20 = 0; num20 < num19; num20++)
            {
                Dust obj5 = Dust.NewDustDirect(position2, effectRect.Width, effectRect.Height + 24, 35);
                obj5.velocity.Y *= 0f;
                obj5.velocity.Y -= 3.5f;
                obj5.velocity.X *= 1.5f;
                obj5.scale = 0.8f;
                obj5.alpha = 130;
                obj5.noGravity = true;
                obj5.fadeIn = 1.2f;
            }
            SoundEngine.PlaySound(SoundID.Item8, effectRect.Center.ToVector2());
            break;
        }
        case 9:
        {
            effectRect.Inflate(15, 15);
            int num13 = (int)(100f * dustCountMult);
            for (int num14 = 0; num14 < num13; num14++)
            {
                TeleportPylonsSystem.SpawnInWorldDust(extraInfo, effectRect);
            }
            SoundEngine.PlaySound(SoundID.Item6, effectRect.Center.X, effectRect.Center.Y);
            break;
        }
        case 10:
        {
            effectRect.Inflate(15, 15);
            int num7 = (int)(60f * dustCountMult);
            Vector2 vector = otherPosition - effectRect.TopLeft();
            for (int n = 0; n < num7; n++)
            {
                float fadeIn = 0.4f + rand.NextFloat();
                float scale = 0.4f + rand.NextFloat();
                Microsoft.Xna.Framework.Color newColor = hslToRgb(0.66f + rand.NextFloat() * 0.24f, 1f, 0.5f);
                Dust dust = Dust.NewDustDirect(effectRect.TopLeft(), effectRect.Width, effectRect.Height, 267, 0f, 0f, 127, newColor);
                dust.scale = (float)rand.Next(20, 70) * 0.01f;
                if (n < 10)
                {
                    dust.scale += 0.25f;
                }
                if (n < 5)
                {
                    dust.scale += 0.25f;
                }
                if ((float)n < (float)num7 * 0.8f)
                {
                    dust.velocity += vector * 0.1f * rand.NextFloat();
                }
                dust.noGravity = true;
                dust.noLight = true;
                dust.scale = scale;
                dust.fadeIn = fadeIn;
                if (dust.dustIndex != 6000)
                {
                    Dust obj2 = Dust.CloneDust(dust);
                    obj2.scale *= 0.65f;
                    obj2.fadeIn *= 0.65f;
                    obj2.color = new Microsoft.Xna.Framework.Color(255, 255, 255, 255);
                }
            }
            SoundEngine.PlaySound(SoundID.Item8, effectRect.Center.X, effectRect.Center.Y);
            break;
        }
        case 11:
        {
            for (int k = 0; k < 50; k++)
            {
                int num4 = rand.Next(4);
                Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Green;
                switch (num4)
                {
                case 0:
                case 1:
                    color = new Microsoft.Xna.Framework.Color(100, 255, 100);
                    break;
                case 2:
                    color = Microsoft.Xna.Framework.Color.Yellow;
                    break;
                case 3:
                    color = Microsoft.Xna.Framework.Color.White;
                    break;
                }
                Dust obj = Dust.NewDustPerfect(rand.NextVector2FromRectangle(effectRect), 267);
                obj.noGravity = true;
                obj.color = color;
                obj.velocity *= 2f;
                obj.scale = 0.8f + rand.NextFloat() * 0.6f;
                obj.fadeIn = 0.5f;
            }
            break;
        }
        case 13:
        {
            SoundEngine.PlaySound(SoundID.Item8, effectRect.Center.ToVector2());
            for (int i = 0; i < 21; i++)
            {
                int num = Dust.NewDust(rand.NextVector2FromRectangle(effectRect), 2, 2, 27, 0f, 0f, 100, default(Microsoft.Xna.Framework.Color), rand.Next(1, 3));
                Main.dust[num].velocity *= 1.75f;
                if (i % 3 == 0)
                {
                    Main.dust[num].velocity *= 1.5f;
                }
                Main.dust[num].noLightEmittence = true;
                Main.dust[num].noGravity = true;
            }
            break;
        }
        }
    }
 
    public static void Ambience()
    {
        ambientCounter++;
        if (ambientCounter < 15)
        {
            return;
        }
        ambientCounter = 0;
        Microsoft.Xna.Framework.Point point = LocalPlayer.Center.ToPoint();
        if (ambientWaterfallStrength > 0f)
        {
            SoundEngine.PlaySound(34, (int)ambientWaterfallX, (int)ambientWaterfallY, (int)ambientWaterfallStrength);
            _isWaterfallMusicPlaying = true;
        }
        else
        {
            if (_isWaterfallMusicPlaying)
            {
                SoundEngine.PlaySound(34, point.X, point.Y, 0);
            }
            _isWaterfallMusicPlaying = false;
        }
        float num = Math.Abs(ambientLavaX - (screenPosition.X + (float)(screenWidth / 2))) + Math.Abs(ambientLavaY - (screenPosition.Y + (float)(screenHeight / 2)));
        float num2 = Math.Abs(ambientLavafallX - (screenPosition.X + (float)(screenWidth / 2))) + Math.Abs(ambientLavafallY - (screenPosition.Y + (float)(screenHeight / 2)));
        float num3 = ambientLavaX;
        float num4 = ambientLavaY;
        if (num2 < num)
        {
            num3 = ambientLavafallX;
            num4 = ambientLavafallY;
        }
        float num5 = ambientLavafallStrength + ambientLavaStrength;
        if (ambientLavafallStrength > 0f)
        {
            SoundEngine.PlaySound(35, (int)num3, (int)num4, (int)num5);
            _isLavafallMusicPlaying = true;
            return;
        }
        if (_isLavafallMusicPlaying)
        {
            SoundEngine.PlaySound(35, point.X, point.Y, 0);
        }
        _isLavafallMusicPlaying = false;
    }
 
    public static void AnimateTiles_CritterCages()
    {
        if (!critterCage)
        {
            return;
        }
        for (int i = 0; i < cageFrames; i++)
        {
            if (bunnyCageFrame[i] == 0)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] <= rand.Next(30, 900))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    int num = rand.Next(7);
                    if (num == 0)
                    {
                        bunnyCageFrame[i] = 4;
                    }
                    else if (num <= 2)
                    {
                        bunnyCageFrame[i] = 2;
                    }
                    else
                    {
                        bunnyCageFrame[i] = 1;
                    }
                }
                bunnyCageFrameCounter[i] = 0;
            }
            else if (bunnyCageFrame[i] == 1)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] >= 10)
                {
                    bunnyCageFrameCounter[i] = 0;
                    bunnyCageFrame[i] = 0;
                }
            }
            else if (bunnyCageFrame[i] >= 2 && bunnyCageFrame[i] <= 3)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] >= 10)
                {
                    bunnyCageFrameCounter[i] = 0;
                    bunnyCageFrame[i]++;
                }
                if (bunnyCageFrame[i] > 3)
                {
                    bunnyCageFrame[i] = 0;
                }
            }
            else if (bunnyCageFrame[i] >= 4 && bunnyCageFrame[i] <= 10)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] >= 5)
                {
                    bunnyCageFrameCounter[i] = 0;
                    bunnyCageFrame[i]++;
                }
            }
            else if (bunnyCageFrame[i] == 11)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] <= rand.Next(30, 900))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(7) == 0)
                    {
                        bunnyCageFrame[i] = 13;
                    }
                    else
                    {
                        bunnyCageFrame[i] = 12;
                    }
                }
                bunnyCageFrameCounter[i] = 0;
            }
            else if (bunnyCageFrame[i] == 12)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] >= 10)
                {
                    bunnyCageFrameCounter[i] = 0;
                    bunnyCageFrame[i] = 11;
                }
            }
            else if (bunnyCageFrame[i] >= 13)
            {
                bunnyCageFrameCounter[i]++;
                if (bunnyCageFrameCounter[i] >= 5)
                {
                    bunnyCageFrameCounter[i] = 0;
                    bunnyCageFrame[i]++;
                }
                if (bunnyCageFrame[i] > 21)
                {
                    bunnyCageFrame[i] = 0;
                }
            }
        }
        for (int j = 0; j < cageFrames; j++)
        {
            if (squirrelCageFrame[j] == 0)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] <= rand.Next(30, 900))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    int num = rand.Next(7);
                    if (num == 0)
                    {
                        squirrelCageFrame[j] = 4;
                    }
                    else if (num <= 2)
                    {
                        squirrelCageFrame[j] = 2;
                    }
                    else
                    {
                        squirrelCageFrame[j] = 1;
                    }
                }
                squirrelCageFrameCounter[j] = 0;
            }
            else if (squirrelCageFrame[j] == 1)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] >= 10)
                {
                    squirrelCageFrameCounter[j] = 0;
                    squirrelCageFrame[j] = 0;
                }
            }
            else if (squirrelCageFrame[j] >= 2 && squirrelCageFrame[j] <= 3)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] >= 5)
                {
                    squirrelCageFrameCounter[j] = 0;
                    squirrelCageFrame[j]++;
                }
                if (squirrelCageFrame[j] > 3)
                {
                    if (rand.Next(5) == 0)
                    {
                        squirrelCageFrame[j] = 0;
                    }
                    else
                    {
                        squirrelCageFrame[j] = 2;
                    }
                }
            }
            else if (squirrelCageFrame[j] >= 4 && squirrelCageFrame[j] <= 8)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] >= 5)
                {
                    squirrelCageFrameCounter[j] = 0;
                    squirrelCageFrame[j]++;
                }
            }
            else if (squirrelCageFrame[j] == 9)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] <= rand.Next(30, 900))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    int num = rand.Next(7);
                    if (num == 0)
                    {
                        squirrelCageFrame[j] = 13;
                    }
                    else if (num <= 2)
                    {
                        squirrelCageFrame[j] = 11;
                    }
                    else
                    {
                        squirrelCageFrame[j] = 10;
                    }
                }
                squirrelCageFrameCounter[j] = 0;
            }
            else if (squirrelCageFrame[j] == 10)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] >= 10)
                {
                    squirrelCageFrameCounter[j] = 0;
                    squirrelCageFrame[j] = 9;
                }
            }
            else if (squirrelCageFrame[j] == 11 || squirrelCageFrame[j] == 12)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] < 5)
                {
                    continue;
                }
                squirrelCageFrame[j]++;
                if (squirrelCageFrame[j] > 12)
                {
                    if (rand.Next(5) != 0)
                    {
                        squirrelCageFrame[j] = 11;
                    }
                    else
                    {
                        squirrelCageFrame[j] = 9;
                    }
                }
                squirrelCageFrameCounter[j] = 0;
            }
            else if (squirrelCageFrame[j] >= 13)
            {
                squirrelCageFrameCounter[j]++;
                if (squirrelCageFrameCounter[j] >= 5)
                {
                    squirrelCageFrameCounter[j] = 0;
                    squirrelCageFrame[j]++;
                }
                if (squirrelCageFrame[j] > 17)
                {
                    squirrelCageFrame[j] = 0;
                }
            }
        }
        for (int k = 0; k < cageFrames; k++)
        {
            if (squirrelCageFrameOrange[k] == 0)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] <= rand.Next(30, 900))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    int num = rand.Next(7);
                    if (num == 0)
                    {
                        squirrelCageFrameOrange[k] = 4;
                    }
                    else if (num <= 2)
                    {
                        squirrelCageFrameOrange[k] = 2;
                    }
                    else
                    {
                        squirrelCageFrameOrange[k] = 1;
                    }
                }
                squirrelCageFrameCounterOrange[k] = 0;
            }
            else if (squirrelCageFrameOrange[k] == 1)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] >= 10)
                {
                    squirrelCageFrameCounterOrange[k] = 0;
                    squirrelCageFrameOrange[k] = 0;
                }
            }
            else if (squirrelCageFrameOrange[k] >= 2 && squirrelCageFrameOrange[k] <= 3)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] >= 5)
                {
                    squirrelCageFrameCounterOrange[k] = 0;
                    squirrelCageFrameOrange[k]++;
                }
                if (squirrelCageFrameOrange[k] > 3)
                {
                    if (rand.Next(5) == 0)
                    {
                        squirrelCageFrameOrange[k] = 0;
                    }
                    else
                    {
                        squirrelCageFrameOrange[k] = 2;
                    }
                }
            }
            else if (squirrelCageFrameOrange[k] >= 4 && squirrelCageFrameOrange[k] <= 8)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] >= 5)
                {
                    squirrelCageFrameCounterOrange[k] = 0;
                    squirrelCageFrameOrange[k]++;
                }
            }
            else if (squirrelCageFrameOrange[k] == 9)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] <= rand.Next(30, 900))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    int num = rand.Next(7);
                    if (num == 0)
                    {
                        squirrelCageFrameOrange[k] = 13;
                    }
                    else if (num <= 2)
                    {
                        squirrelCageFrameOrange[k] = 11;
                    }
                    else
                    {
                        squirrelCageFrameOrange[k] = 10;
                    }
                }
                squirrelCageFrameCounterOrange[k] = 0;
            }
            else if (squirrelCageFrameOrange[k] == 10)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] >= 10)
                {
                    squirrelCageFrameCounterOrange[k] = 0;
                    squirrelCageFrameOrange[k] = 9;
                }
            }
            else if (squirrelCageFrameOrange[k] == 11 || squirrelCageFrameOrange[k] == 12)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] < 5)
                {
                    continue;
                }
                squirrelCageFrameOrange[k]++;
                if (squirrelCageFrameOrange[k] > 12)
                {
                    if (rand.Next(5) != 0)
                    {
                        squirrelCageFrameOrange[k] = 11;
                    }
                    else
                    {
                        squirrelCageFrameOrange[k] = 9;
                    }
                }
                squirrelCageFrameCounterOrange[k] = 0;
            }
            else if (squirrelCageFrameOrange[k] >= 13)
            {
                squirrelCageFrameCounterOrange[k]++;
                if (squirrelCageFrameCounterOrange[k] >= 5)
                {
                    squirrelCageFrameCounterOrange[k] = 0;
                    squirrelCageFrameOrange[k]++;
                }
                if (squirrelCageFrameOrange[k] > 17)
                {
                    squirrelCageFrameOrange[k] = 0;
                }
            }
        }
        for (int l = 0; l < cageFrames; l++)
        {
            if (mallardCageFrame[l] == 0 || mallardCageFrame[l] == 4)
            {
                mallardCageFrameCounter[l]++;
                if (mallardCageFrameCounter[l] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if ((mallardCageFrame[l] == 0 && rand.Next(3) != 0) || (mallardCageFrame[l] == 4 && rand.Next(5) == 0))
                {
                    if (rand.Next(6) == 0)
                    {
                        mallardCageFrame[l] = 5;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        if (mallardCageFrame[l] == 4)
                        {
                            mallardCageFrame[l] = 0;
                        }
                        else
                        {
                            mallardCageFrame[l] = 4;
                        }
                    }
                    else
                    {
                        mallardCageFrame[l] = 1;
                    }
                }
                mallardCageFrameCounter[l] = 0;
            }
            else if (mallardCageFrame[l] >= 1 && mallardCageFrame[l] <= 3)
            {
                mallardCageFrameCounter[l]++;
                if (mallardCageFrameCounter[l] >= 5)
                {
                    mallardCageFrameCounter[l] = 0;
                    mallardCageFrame[l]++;
                }
                if (mallardCageFrame[l] > 3)
                {
                    if (rand.Next(5) == 0)
                    {
                        mallardCageFrame[l] = 0;
                    }
                    else
                    {
                        mallardCageFrame[l] = 1;
                    }
                }
            }
            else if (mallardCageFrame[l] >= 5 && mallardCageFrame[l] <= 11)
            {
                mallardCageFrameCounter[l]++;
                if (mallardCageFrameCounter[l] >= 5)
                {
                    mallardCageFrameCounter[l] = 0;
                    mallardCageFrame[l]++;
                }
            }
            else if (mallardCageFrame[l] == 12 || mallardCageFrame[l] == 16)
            {
                mallardCageFrameCounter[l]++;
                if (mallardCageFrameCounter[l] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if ((mallardCageFrame[l] == 12 && rand.Next(3) != 0) || (mallardCageFrame[l] == 16 && rand.Next(5) == 0))
                {
                    if (rand.Next(6) == 0)
                    {
                        mallardCageFrame[l] = 17;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        if (mallardCageFrame[l] == 16)
                        {
                            mallardCageFrame[l] = 12;
                        }
                        else
                        {
                            mallardCageFrame[l] = 16;
                        }
                    }
                    else
                    {
                        mallardCageFrame[l] = 13;
                    }
                }
                mallardCageFrameCounter[l] = 0;
            }
            else if (mallardCageFrame[l] >= 13 && mallardCageFrame[l] <= 15)
            {
                mallardCageFrameCounter[l]++;
                if (mallardCageFrameCounter[l] < 5)
                {
                    continue;
                }
                mallardCageFrame[l]++;
                if (mallardCageFrame[l] > 15)
                {
                    if (rand.Next(5) != 0)
                    {
                        mallardCageFrame[l] = 12;
                    }
                    else
                    {
                        mallardCageFrame[l] = 13;
                    }
                }
                mallardCageFrameCounter[l] = 0;
            }
            else if (mallardCageFrame[l] >= 17)
            {
                mallardCageFrameCounter[l]++;
                if (mallardCageFrameCounter[l] >= 5)
                {
                    mallardCageFrameCounter[l] = 0;
                    mallardCageFrame[l]++;
                }
                if (mallardCageFrame[l] > 23)
                {
                    mallardCageFrame[l] = 0;
                }
            }
        }
        for (int m = 0; m < cageFrames; m++)
        {
            if (duckCageFrame[m] == 0 || duckCageFrame[m] == 4)
            {
                duckCageFrameCounter[m]++;
                if (duckCageFrameCounter[m] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if ((duckCageFrame[m] == 0 && rand.Next(3) != 0) || (duckCageFrame[m] == 4 && rand.Next(5) == 0))
                {
                    if (rand.Next(6) == 0)
                    {
                        duckCageFrame[m] = 5;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        if (duckCageFrame[m] == 4)
                        {
                            duckCageFrame[m] = 0;
                        }
                        else
                        {
                            duckCageFrame[m] = 4;
                        }
                    }
                    else
                    {
                        duckCageFrame[m] = 1;
                    }
                }
                duckCageFrameCounter[m] = 0;
            }
            else if (duckCageFrame[m] >= 1 && duckCageFrame[m] <= 3)
            {
                duckCageFrameCounter[m]++;
                if (duckCageFrameCounter[m] >= 5)
                {
                    duckCageFrameCounter[m] = 0;
                    duckCageFrame[m]++;
                }
                if (duckCageFrame[m] > 3)
                {
                    if (rand.Next(5) == 0)
                    {
                        duckCageFrame[m] = 0;
                    }
                    else
                    {
                        duckCageFrame[m] = 1;
                    }
                }
            }
            else if (duckCageFrame[m] >= 5 && duckCageFrame[m] <= 11)
            {
                duckCageFrameCounter[m]++;
                if (duckCageFrameCounter[m] >= 5)
                {
                    duckCageFrameCounter[m] = 0;
                    duckCageFrame[m]++;
                }
            }
            else if (duckCageFrame[m] == 12 || duckCageFrame[m] == 16)
            {
                duckCageFrameCounter[m]++;
                if (duckCageFrameCounter[m] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if ((duckCageFrame[m] == 12 && rand.Next(3) != 0) || (duckCageFrame[m] == 16 && rand.Next(5) == 0))
                {
                    if (rand.Next(6) == 0)
                    {
                        duckCageFrame[m] = 17;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        if (duckCageFrame[m] == 16)
                        {
                            duckCageFrame[m] = 12;
                        }
                        else
                        {
                            duckCageFrame[m] = 16;
                        }
                    }
                    else
                    {
                        duckCageFrame[m] = 13;
                    }
                }
                duckCageFrameCounter[m] = 0;
            }
            else if (duckCageFrame[m] >= 13 && duckCageFrame[m] <= 15)
            {
                duckCageFrameCounter[m]++;
                if (duckCageFrameCounter[m] < 5)
                {
                    continue;
                }
                duckCageFrame[m]++;
                if (duckCageFrame[m] > 15)
                {
                    if (rand.Next(5) != 0)
                    {
                        duckCageFrame[m] = 12;
                    }
                    else
                    {
                        duckCageFrame[m] = 13;
                    }
                }
                duckCageFrameCounter[m] = 0;
            }
            else if (duckCageFrame[m] >= 17)
            {
                duckCageFrameCounter[m]++;
                if (duckCageFrameCounter[m] >= 5)
                {
                    duckCageFrameCounter[m] = 0;
                    duckCageFrame[m]++;
                }
                if (duckCageFrame[m] > 23)
                {
                    duckCageFrame[m] = 0;
                }
            }
        }
        for (int n = 0; n < cageFrames; n++)
        {
            grebeCageFrameCounter[n]++;
            bool flag = grebeCageFrame[n] == 0 || grebeCageFrame[n] == 7;
            bool num2 = grebeCageFrame[n] == 16 || grebeCageFrame[n] == 20;
            int num3 = 5;
            if (flag)
            {
                num3 = rand.Next(300, 400);
            }
            if (num2)
            {
                num3 = rand.Next(480, 600);
            }
            if (grebeCageFrameCounter[n] < num3)
            {
                continue;
            }
            grebeCageFrameCounter[n] = 0;
            if (grebeCageFrame[n] >= 25 && grebeCageFrame[n] <= 27)
            {
                grebeCageFrame[n]++;
                if (grebeCageFrame[n] > 27)
                {
                    if (rand.Next(5) == 0)
                    {
                        grebeCageFrame[n] = 7;
                    }
                    else
                    {
                        grebeCageFrame[n] = 25;
                    }
                }
            }
            else if (grebeCageFrame[n] >= 22 && grebeCageFrame[n] <= 24)
            {
                grebeCageFrame[n]++;
                if (grebeCageFrame[n] > 24)
                {
                    if (rand.Next(5) == 0)
                    {
                        grebeCageFrame[n] = 0;
                    }
                    else
                    {
                        grebeCageFrame[n] = 22;
                    }
                }
            }
            else if (grebeCageFrame[n] == 0 && rand.Next(3) == 0)
            {
                grebeCageFrame[n] = ((rand.Next(2) == 0) ? 22 : 14);
            }
            else if (grebeCageFrame[n] == 7 && rand.Next(3) == 0)
            {
                grebeCageFrame[n] = ((rand.Next(2) == 0) ? 25 : 18);
            }
            else if (grebeCageFrame[n] == 13 || grebeCageFrame[n] == 17)
            {
                grebeCageFrame[n] = 0;
            }
            else if (grebeCageFrame[n] == 21)
            {
                grebeCageFrame[n] = 7;
            }
            else
            {
                grebeCageFrame[n]++;
            }
        }
        for (int num4 = 0; num4 < cageFrames; num4++)
        {
            seagullCageFrameCounter[num4]++;
            bool flag2 = seagullCageFrame[num4] == 0 || seagullCageFrame[num4] == 14;
            bool flag3 = seagullCageFrame[num4] >= 15 && seagullCageFrame[num4] <= 18;
            bool num5 = seagullCageFrame[num4] >= 9 && seagullCageFrame[num4] <= 13;
            int num6 = 6;
            if (flag2)
            {
                num6 = rand.Next(180, 250);
            }
            if (flag3)
            {
                num6 = 66;
            }
            if (num5)
            {
                num6 = 78;
            }
            if (seagullCageFrameCounter[num4] >= num6)
            {
                seagullCageFrameCounter[num4] = 0;
                if (seagullCageFrame[num4] == 0 && rand.Next(3) == 0)
                {
                    seagullCageFrame[num4] = 9;
                    continue;
                }
                if (seagullCageFrame[num4] == 14)
                {
                    if (rand.Next(2) == 0)
                    {
                        seagullCageFrame[num4] = 15;
                    }
                    else
                    {
                        seagullCageFrame[num4] = 19;
                    }
                    continue;
                }
                if (seagullCageFrame[num4] == 9)
                {
                    seagullCageFrame[num4] = 0;
                    continue;
                }
                if (seagullCageFrame[num4] == 8 || seagullCageFrame[num4] == 15)
                {
                    seagullCageFrame[num4] = 14;
                    continue;
                }
                seagullCageFrame[num4]++;
                if (seagullCageFrame[num4] > 26)
                {
                    seagullCageFrame[num4] = 0;
                }
            }
            else if (seagullCageFrame[num4] >= 15 && seagullCageFrame[num4] <= 18)
            {
                int num7 = seagullCageFrameCounter[num4] % 66;
                if (num7 > 60)
                {
                    seagullCageFrame[num4] = 15;
                }
                else if (num7 > 54)
                {
                    seagullCageFrame[num4] = 16;
                }
                else if (num7 > 48)
                {
                    seagullCageFrame[num4] = 17;
                }
                else if (num7 > 42)
                {
                    seagullCageFrame[num4] = 18;
                }
                else if (num7 > 36)
                {
                    seagullCageFrame[num4] = 17;
                }
                else if (num7 > 30)
                {
                    seagullCageFrame[num4] = 16;
                }
                else if (num7 > 24)
                {
                    seagullCageFrame[num4] = 17;
                }
                else if (num7 > 18)
                {
                    seagullCageFrame[num4] = 18;
                }
                else if (num7 > 12)
                {
                    seagullCageFrame[num4] = 17;
                }
                else if (num7 > 6)
                {
                    seagullCageFrame[num4] = 16;
                }
                else
                {
                    seagullCageFrame[num4] = 15;
                }
            }
            else if (seagullCageFrame[num4] >= 9 && seagullCageFrame[num4] <= 13)
            {
                int num8 = seagullCageFrameCounter[num4] % 78;
                if (num8 > 72)
                {
                    seagullCageFrame[num4] = 9;
                }
                else if (num8 > 66)
                {
                    seagullCageFrame[num4] = 10;
                }
                else if (num8 > 60)
                {
                    seagullCageFrame[num4] = 11;
                }
                else if (num8 > 54)
                {
                    seagullCageFrame[num4] = 12;
                }
                else if (num8 > 48)
                {
                    seagullCageFrame[num4] = 13;
                }
                else if (num8 > 42)
                {
                    seagullCageFrame[num4] = 12;
                }
                else if (num8 > 36)
                {
                    seagullCageFrame[num4] = 11;
                }
                else if (num8 > 30)
                {
                    seagullCageFrame[num4] = 12;
                }
                else if (num8 > 24)
                {
                    seagullCageFrame[num4] = 13;
                }
                else if (num8 > 18)
                {
                    seagullCageFrame[num4] = 12;
                }
                else if (num8 > 12)
                {
                    seagullCageFrame[num4] = 11;
                }
                else if (num8 > 6)
                {
                    seagullCageFrame[num4] = 10;
                }
                else
                {
                    seagullCageFrame[num4] = 9;
                }
            }
        }
        for (int num9 = 0; num9 < cageFrames; num9++)
        {
            if (birdCageFrame[num9] == 0)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] <= rand.Next(30, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(3) != 0)
                    {
                        birdCageFrame[num9] = 2;
                    }
                    else
                    {
                        birdCageFrame[num9] = 1;
                    }
                }
                birdCageFrameCounter[num9] = 0;
            }
            else if (birdCageFrame[num9] == 1)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] > rand.Next(900, 18000) && rand.Next(3) == 0)
                {
                    birdCageFrameCounter[num9] = 0;
                    birdCageFrame[num9] = 0;
                }
            }
            else if (birdCageFrame[num9] >= 2 && birdCageFrame[num9] <= 5)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] >= 5)
                {
                    birdCageFrameCounter[num9] = 0;
                    if (birdCageFrame[num9] == 3 && rand.Next(3) == 0)
                    {
                        birdCageFrame[num9] = 13;
                    }
                    else
                    {
                        birdCageFrame[num9]++;
                    }
                }
            }
            else if (birdCageFrame[num9] == 6)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(6) == 0)
                    {
                        birdCageFrame[num9] = 7;
                    }
                    else if (rand.Next(6) == 0)
                    {
                        birdCageFrame[num9] = 11;
                    }
                }
                birdCageFrameCounter[num9] = 0;
            }
            else if (birdCageFrame[num9] >= 7 && birdCageFrame[num9] <= 10)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] >= 5)
                {
                    birdCageFrame[num9]++;
                    if (birdCageFrame[num9] > 10)
                    {
                        birdCageFrame[num9] = 0;
                    }
                    birdCageFrameCounter[num9] = 0;
                }
            }
            else if (birdCageFrame[num9] >= 11 && birdCageFrame[num9] <= 13)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] >= 5)
                {
                    birdCageFrame[num9]++;
                    birdCageFrameCounter[num9] = 0;
                }
            }
            else if (birdCageFrame[num9] == 14)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] > rand.Next(5, 600))
                {
                    if (rand.Next(20) == 0)
                    {
                        birdCageFrame[num9] = 16;
                    }
                    else if (rand.Next(20) == 0)
                    {
                        birdCageFrame[num9] = 4;
                    }
                    else
                    {
                        birdCageFrame[num9] = 15;
                    }
                    birdCageFrameCounter[num9] = 0;
                }
            }
            else if (birdCageFrame[num9] == 15)
            {
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] >= 10)
                {
                    birdCageFrameCounter[num9] = 0;
                    birdCageFrame[num9] = 14;
                }
            }
            else
            {
                if (birdCageFrame[num9] < 16 || birdCageFrame[num9] > 18)
                {
                    continue;
                }
                birdCageFrameCounter[num9]++;
                if (birdCageFrameCounter[num9] >= 5)
                {
                    birdCageFrame[num9]++;
                    if (birdCageFrame[num9] > 18)
                    {
                        birdCageFrame[num9] = 0;
                    }
                    birdCageFrameCounter[num9] = 0;
                }
            }
        }
        for (int num10 = 0; num10 < cageFrames; num10++)
        {
            if (blueBirdCageFrame[num10] == 0)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] <= rand.Next(30, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(3) != 0)
                    {
                        blueBirdCageFrame[num10] = 2;
                    }
                    else
                    {
                        blueBirdCageFrame[num10] = 1;
                    }
                }
                blueBirdCageFrameCounter[num10] = 0;
            }
            else if (blueBirdCageFrame[num10] == 1)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] > rand.Next(900, 18000) && rand.Next(3) == 0)
                {
                    blueBirdCageFrameCounter[num10] = 0;
                    blueBirdCageFrame[num10] = 0;
                }
            }
            else if (blueBirdCageFrame[num10] >= 2 && blueBirdCageFrame[num10] <= 5)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] >= 5)
                {
                    blueBirdCageFrameCounter[num10] = 0;
                    if (blueBirdCageFrame[num10] == 3 && rand.Next(3) == 0)
                    {
                        blueBirdCageFrame[num10] = 13;
                    }
                    else
                    {
                        blueBirdCageFrame[num10]++;
                    }
                }
            }
            else if (blueBirdCageFrame[num10] == 6)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(6) == 0)
                    {
                        blueBirdCageFrame[num10] = 7;
                    }
                    else if (rand.Next(6) == 0)
                    {
                        blueBirdCageFrame[num10] = 11;
                    }
                }
                blueBirdCageFrameCounter[num10] = 0;
            }
            else if (blueBirdCageFrame[num10] >= 7 && blueBirdCageFrame[num10] <= 10)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] >= 5)
                {
                    blueBirdCageFrame[num10]++;
                    if (blueBirdCageFrame[num10] > 10)
                    {
                        blueBirdCageFrame[num10] = 0;
                    }
                    blueBirdCageFrameCounter[num10] = 0;
                }
            }
            else if (blueBirdCageFrame[num10] >= 11 && blueBirdCageFrame[num10] <= 13)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] >= 5)
                {
                    blueBirdCageFrame[num10]++;
                    blueBirdCageFrameCounter[num10] = 0;
                }
            }
            else if (blueBirdCageFrame[num10] == 14)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] > rand.Next(5, 600))
                {
                    if (rand.Next(20) == 0)
                    {
                        blueBirdCageFrame[num10] = 16;
                    }
                    else if (rand.Next(20) == 0)
                    {
                        blueBirdCageFrame[num10] = 4;
                    }
                    else
                    {
                        blueBirdCageFrame[num10] = 15;
                    }
                    blueBirdCageFrameCounter[num10] = 0;
                }
            }
            else if (blueBirdCageFrame[num10] == 15)
            {
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] >= 10)
                {
                    blueBirdCageFrameCounter[num10] = 0;
                    blueBirdCageFrame[num10] = 14;
                }
            }
            else
            {
                if (blueBirdCageFrame[num10] < 16 || blueBirdCageFrame[num10] > 18)
                {
                    continue;
                }
                blueBirdCageFrameCounter[num10]++;
                if (blueBirdCageFrameCounter[num10] >= 5)
                {
                    blueBirdCageFrame[num10]++;
                    if (blueBirdCageFrame[num10] > 18)
                    {
                        blueBirdCageFrame[num10] = 0;
                    }
                    blueBirdCageFrameCounter[num10] = 0;
                }
            }
        }
        for (int num11 = 0; num11 < cageFrames; num11++)
        {
            if (redBirdCageFrame[num11] == 0)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] <= rand.Next(30, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(3) != 0)
                    {
                        redBirdCageFrame[num11] = 2;
                    }
                    else
                    {
                        redBirdCageFrame[num11] = 1;
                    }
                }
                redBirdCageFrameCounter[num11] = 0;
            }
            else if (redBirdCageFrame[num11] == 1)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] > rand.Next(900, 18000) && rand.Next(3) == 0)
                {
                    redBirdCageFrameCounter[num11] = 0;
                    redBirdCageFrame[num11] = 0;
                }
            }
            else if (redBirdCageFrame[num11] >= 2 && redBirdCageFrame[num11] <= 5)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] >= 5)
                {
                    redBirdCageFrameCounter[num11] = 0;
                    if (redBirdCageFrame[num11] == 3 && rand.Next(3) == 0)
                    {
                        redBirdCageFrame[num11] = 13;
                    }
                    else
                    {
                        redBirdCageFrame[num11]++;
                    }
                }
            }
            else if (redBirdCageFrame[num11] == 6)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] <= rand.Next(45, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(6) == 0)
                    {
                        redBirdCageFrame[num11] = 7;
                    }
                    else if (rand.Next(6) == 0)
                    {
                        redBirdCageFrame[num11] = 11;
                    }
                }
                redBirdCageFrameCounter[num11] = 0;
            }
            else if (redBirdCageFrame[num11] >= 7 && redBirdCageFrame[num11] <= 10)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] >= 5)
                {
                    redBirdCageFrame[num11]++;
                    if (redBirdCageFrame[num11] > 10)
                    {
                        redBirdCageFrame[num11] = 0;
                    }
                    redBirdCageFrameCounter[num11] = 0;
                }
            }
            else if (redBirdCageFrame[num11] >= 11 && redBirdCageFrame[num11] <= 13)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] >= 5)
                {
                    redBirdCageFrame[num11]++;
                    redBirdCageFrameCounter[num11] = 0;
                }
            }
            else if (redBirdCageFrame[num11] == 14)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] > rand.Next(5, 600))
                {
                    if (rand.Next(20) == 0)
                    {
                        redBirdCageFrame[num11] = 16;
                    }
                    else if (rand.Next(20) == 0)
                    {
                        redBirdCageFrame[num11] = 4;
                    }
                    else
                    {
                        redBirdCageFrame[num11] = 15;
                    }
                    redBirdCageFrameCounter[num11] = 0;
                }
            }
            else if (redBirdCageFrame[num11] == 15)
            {
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] >= 10)
                {
                    redBirdCageFrameCounter[num11] = 0;
                    redBirdCageFrame[num11] = 14;
                }
            }
            else
            {
                if (redBirdCageFrame[num11] < 16 || redBirdCageFrame[num11] > 18)
                {
                    continue;
                }
                redBirdCageFrameCounter[num11]++;
                if (redBirdCageFrameCounter[num11] >= 5)
                {
                    redBirdCageFrame[num11]++;
                    if (redBirdCageFrame[num11] > 18)
                    {
                        redBirdCageFrame[num11] = 0;
                    }
                    redBirdCageFrameCounter[num11] = 0;
                }
            }
        }
        for (int num12 = 0; num12 < cageFrames; num12++)
        {
            if (macawCageFrame[num12] == 0)
            {
                macawCageFrameCounter[num12]++;
                if (macawCageFrameCounter[num12] <= rand.Next(300, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(3) != 0)
                    {
                        macawCageFrame[num12] = 16;
                    }
                    else
                    {
                        macawCageFrame[num12] = 1;
                    }
                }
                macawCageFrameCounter[num12] = 0;
            }
            else if (macawCageFrame[num12] >= 1 && macawCageFrame[num12] <= 5)
            {
                macawCageFrameCounter[num12]++;
                if (macawCageFrameCounter[num12] > 5)
                {
                    macawCageFrameCounter[num12] = 0;
                    macawCageFrame[num12]++;
                    if (macawCageFrame[num12] > 5)
                    {
                        macawCageFrame[num12] = 6;
                    }
                }
            }
            else if (macawCageFrame[num12] >= 16 && macawCageFrame[num12] <= 19)
            {
                macawCageFrameCounter[num12]++;
                if (macawCageFrameCounter[num12] > 6)
                {
                    macawCageFrameCounter[num12] = 0;
                    macawCageFrame[num12]++;
                    if (macawCageFrame[num12] > 19)
                    {
                        macawCageFrame[num12] = ((rand.Next(3) != 0) ? 16 : 0);
                    }
                }
            }
            else if (macawCageFrame[num12] == 6)
            {
                macawCageFrameCounter[num12]++;
                if (macawCageFrameCounter[num12] <= rand.Next(300, 2700))
                {
                    continue;
                }
                if (rand.Next(3) != 0)
                {
                    if (rand.Next(3) != 0)
                    {
                        macawCageFrame[num12] = 7;
                    }
                    else
                    {
                        macawCageFrame[num12] = 11;
                    }
                }
                macawCageFrameCounter[num12] = 0;
            }
            else if (macawCageFrame[num12] >= 11 && macawCageFrame[num12] <= 15)
            {
                macawCageFrameCounter[num12]++;
                if (macawCageFrameCounter[num12] > 5)
                {
                    macawCageFrameCounter[num12] = 0;
                    macawCageFrame[num12]++;
                    if (macawCageFrame[num12] > 15)
                    {
                        macawCageFrame[num12] = 0;
                    }
                }
            }
            else
            {
                if (macawCageFrame[num12] < 7 || macawCageFrame[num12] > 10)
                {
                    continue;
                }
                macawCageFrameCounter[num12]++;
                if (macawCageFrameCounter[num12] > 6)
                {
                    macawCageFrameCounter[num12] = 0;
                    macawCageFrame[num12]++;
                    if (macawCageFrame[num12] > 10)
                    {
                        macawCageFrame[num12] = ((rand.Next(3) == 0) ? 6 : 7);
                    }
                }
            }
        }
        for (int num13 = 0; num13 < 2; num13++)
        {
            for (int num14 = 0; num14 < cageFrames; num14++)
            {
                if (scorpionCageFrame[num13, num14] == 0 || scorpionCageFrame[num13, num14] == 7)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] <= rand.Next(30, 3600))
                    {
                        continue;
                    }
                    if (scorpionCageFrame[num13, num14] == 7)
                    {
                        scorpionCageFrame[num13, num14] = 0;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        if (rand.Next(7) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 1;
                        }
                        else if (rand.Next(4) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 8;
                        }
                        else if (rand.Next(3) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 7;
                        }
                        else
                        {
                            scorpionCageFrame[num13, num14] = 14;
                        }
                    }
                    scorpionCageFrameCounter[num13, num14] = 0;
                }
                else if (scorpionCageFrame[num13, num14] >= 1 && scorpionCageFrame[num13, num14] <= 2)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] >= 10)
                    {
                        scorpionCageFrameCounter[num13, num14] = 0;
                        scorpionCageFrame[num13, num14]++;
                    }
                }
                else if (scorpionCageFrame[num13, num14] >= 8 && scorpionCageFrame[num13, num14] <= 10)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] >= 10)
                    {
                        scorpionCageFrameCounter[num13, num14] = 0;
                        scorpionCageFrame[num13, num14]++;
                    }
                }
                else if (scorpionCageFrame[num13, num14] == 11)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] > rand.Next(45, 5400))
                    {
                        if (rand.Next(6) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 12;
                        }
                        scorpionCageFrameCounter[num13, num14] = 0;
                    }
                }
                else if (scorpionCageFrame[num13, num14] >= 12 && scorpionCageFrame[num13, num14] <= 13)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] >= 10)
                    {
                        scorpionCageFrameCounter[num13, num14] = 0;
                        scorpionCageFrame[num13, num14]++;
                        if (scorpionCageFrame[num13, num14] > 13)
                        {
                            scorpionCageFrame[num13, num14] = 0;
                        }
                    }
                }
                else if (scorpionCageFrame[num13, num14] >= 14 && scorpionCageFrame[num13, num14] <= 15)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] >= 5)
                    {
                        scorpionCageFrameCounter[num13, num14] = 0;
                        scorpionCageFrame[num13, num14]++;
                        if (scorpionCageFrame[num13, num14] > 15)
                        {
                            scorpionCageFrame[num13, num14] = 14;
                        }
                        if (rand.Next(5) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 0;
                        }
                    }
                }
                else if (scorpionCageFrame[num13, num14] == 4 || scorpionCageFrame[num13, num14] == 3)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] <= rand.Next(30, 3600))
                    {
                        continue;
                    }
                    if (scorpionCageFrame[num13, num14] == 3)
                    {
                        scorpionCageFrame[num13, num14] = 4;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        if (rand.Next(5) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 5;
                        }
                        else if (rand.Next(3) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 3;
                        }
                        else
                        {
                            scorpionCageFrame[num13, num14] = 16;
                        }
                    }
                    scorpionCageFrameCounter[num13, num14] = 0;
                }
                else if (scorpionCageFrame[num13, num14] >= 5 && scorpionCageFrame[num13, num14] <= 6)
                {
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] >= 10)
                    {
                        scorpionCageFrameCounter[num13, num14] = 0;
                        scorpionCageFrame[num13, num14]++;
                        if (scorpionCageFrame[num13, num14] > 7)
                        {
                            scorpionCageFrame[num13, num14] = 0;
                        }
                    }
                }
                else
                {
                    if (scorpionCageFrame[num13, num14] < 16 || scorpionCageFrame[num13, num14] > 17)
                    {
                        continue;
                    }
                    scorpionCageFrameCounter[num13, num14]++;
                    if (scorpionCageFrameCounter[num13, num14] >= 5)
                    {
                        scorpionCageFrameCounter[num13, num14] = 0;
                        scorpionCageFrame[num13, num14]++;
                        if (scorpionCageFrame[num13, num14] > 17)
                        {
                            scorpionCageFrame[num13, num14] = 16;
                        }
                        if (rand.Next(5) == 0)
                        {
                            scorpionCageFrame[num13, num14] = 4;
                        }
                    }
                }
            }
        }
        for (int num15 = 0; num15 < cageFrames; num15++)
        {
            if (penguinCageFrame[num15] == 0)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] <= rand.Next(30, 1800))
                {
                    continue;
                }
                if (rand.Next(2) == 0)
                {
                    if (rand.Next(10) == 0)
                    {
                        penguinCageFrame[num15] = 4;
                    }
                    else if (rand.Next(7) == 0)
                    {
                        penguinCageFrame[num15] = 15;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        penguinCageFrame[num15] = 2;
                    }
                    else
                    {
                        penguinCageFrame[num15] = 1;
                    }
                }
                penguinCageFrameCounter[num15] = 0;
            }
            else if (penguinCageFrame[num15] == 1)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] >= 10)
                {
                    penguinCageFrameCounter[num15] = 0;
                    penguinCageFrame[num15] = 0;
                }
            }
            else if (penguinCageFrame[num15] >= 2 && penguinCageFrame[num15] <= 3)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] < 5)
                {
                    continue;
                }
                penguinCageFrameCounter[num15] = 0;
                penguinCageFrame[num15]++;
                if (penguinCageFrame[num15] > 3)
                {
                    if (rand.Next(3) == 0)
                    {
                        penguinCageFrame[num15] = 0;
                    }
                    else
                    {
                        penguinCageFrame[num15] = 2;
                    }
                }
            }
            else if (penguinCageFrame[num15] >= 4 && penguinCageFrame[num15] <= 6)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] >= 10)
                {
                    penguinCageFrameCounter[num15] = 0;
                    penguinCageFrame[num15]++;
                }
            }
            else if (penguinCageFrame[num15] == 15)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] > rand.Next(10, 1800))
                {
                    if (rand.Next(2) == 0)
                    {
                        penguinCageFrame[num15] = 0;
                    }
                    penguinCageFrameCounter[num15] = 0;
                }
            }
            else if (penguinCageFrame[num15] == 8)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] <= rand.Next(30, 3600))
                {
                    continue;
                }
                if (rand.Next(2) == 0)
                {
                    if (rand.Next(10) == 0)
                    {
                        penguinCageFrame[num15] = 12;
                    }
                    else if (rand.Next(7) == 0)
                    {
                        penguinCageFrame[num15] = 7;
                    }
                    else if (rand.Next(3) == 0)
                    {
                        penguinCageFrame[num15] = 10;
                    }
                    else
                    {
                        penguinCageFrame[num15] = 9;
                    }
                }
                penguinCageFrameCounter[num15] = 0;
            }
            else if (penguinCageFrame[num15] == 9)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] >= 10)
                {
                    penguinCageFrameCounter[num15] = 0;
                    penguinCageFrame[num15] = 8;
                }
            }
            else if (penguinCageFrame[num15] >= 10 && penguinCageFrame[num15] <= 11)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] < 5)
                {
                    continue;
                }
                penguinCageFrameCounter[num15] = 0;
                penguinCageFrame[num15]++;
                if (penguinCageFrame[num15] > 3)
                {
                    if (rand.Next(3) == 0)
                    {
                        penguinCageFrame[num15] = 8;
                    }
                    else
                    {
                        penguinCageFrame[num15] = 10;
                    }
                }
            }
            else if (penguinCageFrame[num15] >= 12 && penguinCageFrame[num15] <= 14)
            {
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] >= 10)
                {
                    penguinCageFrameCounter[num15] = 0;
                    penguinCageFrame[num15]++;
                }
            }
            else
            {
                if (penguinCageFrame[num15] != 7)
                {
                    continue;
                }
                penguinCageFrameCounter[num15]++;
                if (penguinCageFrameCounter[num15] > rand.Next(10, 3600))
                {
                    if (rand.Next(2) == 0)
                    {
                        penguinCageFrame[num15] = 8;
                    }
                    penguinCageFrameCounter[num15] = 0;
                }
            }
        }
        for (int num16 = 0; num16 < cageFrames; num16++)
        {
            turtleCageFrameCounter[num16]++;
            bool num17 = turtleCageFrame[num16] == 0 || turtleCageFrame[num16] == 15 || turtleCageFrame[num16] == 31;
            int num18 = 8;
            if (num17)
            {
                num18 = rand.Next(180, 250);
            }
            if (turtleCageFrameCounter[num16] < num18)
            {
                continue;
            }
            turtleCageFrameCounter[num16] = 0;
            if (turtleCageFrame[num16] == 29)
            {
                turtleCageFrame[num16] = 0;
                continue;
            }
            if (turtleCageFrame[num16] == 15 && rand.Next(3) == 0)
            {
                turtleCageFrame[num16] = 30;
                continue;
            }
            turtleCageFrame[num16]++;
            if (turtleCageFrame[num16] > 32)
            {
                turtleCageFrame[num16] = 15;
            }
        }
        for (int num19 = 0; num19 < cageFrames; num19++)
        {
            seahorseCageFrameCounter[num19]++;
            bool flag4 = seahorseCageFrame[num19] == 0 || seahorseCageFrame[num19] == 13;
            bool num20 = seahorseCageFrame[num19] == 4 || seahorseCageFrame[num19] == 9 || seahorseCageFrame[num19] == 17 || seahorseCageFrame[num19] == 22;
            bool flag5 = seahorseCageFrame[num19] >= 25;
            int num21 = 7;
            if (flag4)
            {
                num21 = rand.Next(220, 340);
            }
            if (num20)
            {
                num21 = 10;
            }
            if (flag5)
            {
                num21 = 6;
            }
            if (seahorseCageFrameCounter[num19] < num21)
            {
                continue;
            }
            seahorseCageFrameCounter[num19] = 0;
            if (seahorseCageFrame[num19] == 0 && rand.Next(2) == 0)
            {
                seahorseCageFrame[num19] = 25;
                continue;
            }
            if (seahorseCageFrame[num19] == 24)
            {
                seahorseCageFrame[num19] = 0;
                continue;
            }
            seahorseCageFrame[num19]++;
            if (seahorseCageFrame[num19] > 33)
            {
                seahorseCageFrame[num19] = 0;
            }
        }
        UpdateOwlCageFrames();
        for (int num22 = 0; num22 < cageFrames; num22++)
        {
            if (snailCageFrame[num22] >= 0 && snailCageFrame[num22] <= 13)
            {
                snailCageFrameCounter[num22]++;
                if (snailCageFrameCounter[num22] <= rand.Next(45, 3600))
                {
                    continue;
                }
                if (snailCageFrame[num22] == 8 && rand.Next(2) == 0)
                {
                    snailCageFrame[num22] = 14;
                }
                else if (snailCageFrame[num22] == 1 && rand.Next(3) == 0)
                {
                    snailCageFrame[num22] = 19;
                }
                else if (snailCageFrame[num22] == 1 && rand.Next(3) == 0)
                {
                    snailCageFrame[num22] = 20;
                }
                else
                {
                    snailCageFrame[num22]++;
                    if (snailCageFrame[num22] > 13)
                    {
                        snailCageFrame[num22] = 0;
                    }
                }
                snailCageFrameCounter[num22] = 0;
            }
            else if (snailCageFrame[num22] >= 14 && snailCageFrame[num22] <= 18)
            {
                snailCageFrameCounter[num22]++;
                if (snailCageFrameCounter[num22] >= 5)
                {
                    snailCageFrameCounter[num22] = 0;
                    snailCageFrame[num22]++;
                }
                if (snailCageFrame[num22] > 18)
                {
                    snailCageFrame[num22] = 20;
                }
            }
            else
            {
                if (snailCageFrame[num22] != 19 && snailCageFrame[num22] != 20)
                {
                    continue;
                }
                snailCageFrameCounter[num22]++;
                if (snailCageFrameCounter[num22] <= rand.Next(60, 7200))
                {
                    continue;
                }
                snailCageFrameCounter[num22] = 0;
                if (rand.Next(4) == 0)
                {
                    if (rand.Next(3) == 0)
                    {
                        snailCageFrame[num22] = 2;
                    }
                    else if (snailCageFrame[num22] == 19)
                    {
                        snailCageFrame[num22] = 20;
                    }
                    else
                    {
                        snailCageFrame[num22] = 19;
                    }
                }
            }
        }
        for (int num23 = 0; num23 < cageFrames; num23++)
        {
            if (snail2CageFrame[num23] >= 0 && snail2CageFrame[num23] <= 13)
            {
                snail2CageFrameCounter[num23]++;
                if (snail2CageFrameCounter[num23] <= rand.Next(30, 2700))
                {
                    continue;
                }
                if (snail2CageFrame[num23] == 8 && rand.Next(2) == 0)
                {
                    snail2CageFrame[num23] = 14;
                }
                else if (snail2CageFrame[num23] == 1 && rand.Next(3) == 0)
                {
                    snail2CageFrame[num23] = 19;
                }
                else if (snail2CageFrame[num23] == 1 && rand.Next(3) == 0)
                {
                    snail2CageFrame[num23] = 20;
                }
                else
                {
                    snail2CageFrame[num23]++;
                    if (snail2CageFrame[num23] > 13)
                    {
                        snail2CageFrame[num23] = 0;
                    }
                }
                snail2CageFrameCounter[num23] = 0;
            }
            else if (snail2CageFrame[num23] >= 14 && snail2CageFrame[num23] <= 18)
            {
                snail2CageFrameCounter[num23]++;
                if (snail2CageFrameCounter[num23] >= 5)
                {
                    snail2CageFrameCounter[num23] = 0;
                    snail2CageFrame[num23]++;
                }
                if (snail2CageFrame[num23] > 18)
                {
                    snail2CageFrame[num23] = 20;
                }
            }
            else
            {
                if (snail2CageFrame[num23] != 19 && snail2CageFrame[num23] != 20)
                {
                    continue;
                }
                snail2CageFrameCounter[num23]++;
                if (snail2CageFrameCounter[num23] <= rand.Next(45, 5400))
                {
                    continue;
                }
                snail2CageFrameCounter[num23] = 0;
                if (rand.Next(4) == 0)
                {
                    if (rand.Next(3) == 0)
                    {
                        snail2CageFrame[num23] = 2;
                    }
                    else if (snail2CageFrame[num23] == 19)
                    {
                        snail2CageFrame[num23] = 20;
                    }
                    else
                    {
                        snail2CageFrame[num23] = 19;
                    }
                }
            }
        }
        for (int num24 = 0; num24 < cageFrames; num24++)
        {
            if (frogCageFrame[num24] == 0)
            {
                frogCageFrameCounter[num24]++;
                if (frogCageFrameCounter[num24] > rand.Next(45, 3600))
                {
                    if (rand.Next(10) == 0)
                    {
                        frogCageFrame[num24] = 1;
                    }
                    else
                    {
                        frogCageFrame[num24] = 12;
                    }
                    frogCageFrameCounter[num24] = 0;
                }
            }
            else if (frogCageFrame[num24] >= 1 && frogCageFrame[num24] <= 5)
            {
                frogCageFrameCounter[num24]++;
                if (frogCageFrameCounter[num24] >= 5)
                {
                    frogCageFrame[num24]++;
                    frogCageFrameCounter[num24] = 0;
                }
            }
            else if (frogCageFrame[num24] >= 12 && frogCageFrame[num24] <= 17)
            {
                frogCageFrameCounter[num24]++;
                if (frogCageFrameCounter[num24] >= 5)
                {
                    frogCageFrameCounter[num24] = 0;
                    frogCageFrame[num24]++;
                }
                if (frogCageFrame[num24] > 17)
                {
                    if (rand.Next(3) == 0)
                    {
                        frogCageFrame[num24] = 0;
                    }
                    else
                    {
                        frogCageFrame[num24] = 12;
                    }
                }
            }
            else if (frogCageFrame[num24] == 6)
            {
                frogCageFrameCounter[num24]++;
                if (frogCageFrameCounter[num24] > rand.Next(45, 3600))
                {
                    if (rand.Next(10) == 0)
                    {
                        frogCageFrame[num24] = 7;
                    }
                    else
                    {
                        frogCageFrame[num24] = 18;
                    }
                    frogCageFrameCounter[num24] = 0;
                }
            }
            else if (frogCageFrame[num24] >= 7 && frogCageFrame[num24] <= 11)
            {
                frogCageFrameCounter[num24]++;
                if (frogCageFrameCounter[num24] >= 5)
                {
                    frogCageFrame[num24]++;
                    frogCageFrameCounter[num24] = 0;
                    if (frogCageFrame[num24] > 11)
                    {
                        frogCageFrame[num24] = 0;
                    }
                }
            }
            else
            {
                if (frogCageFrame[num24] < 18 || frogCageFrame[num24] > 23)
                {
                    continue;
                }
                frogCageFrameCounter[num24]++;
                if (frogCageFrameCounter[num24] >= 5)
                {
                    frogCageFrameCounter[num24] = 0;
                    frogCageFrame[num24]++;
                }
                if (frogCageFrame[num24] > 17)
                {
                    if (rand.Next(3) == 0)
                    {
                        frogCageFrame[num24] = 6;
                    }
                    else
                    {
                        frogCageFrame[num24] = 18;
                    }
                }
            }
        }
        for (int num25 = 0; num25 < cageFrames; num25++)
        {
            if (mouseCageFrame[num25] >= 0 && mouseCageFrame[num25] <= 1)
            {
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrame[num25]++;
                    if (mouseCageFrame[num25] > 1)
                    {
                        mouseCageFrame[num25] = 0;
                    }
                    mouseCageFrameCounter[num25] = 0;
                    if (rand.Next(15) == 0)
                    {
                        mouseCageFrame[num25] = 4;
                    }
                }
            }
            else if (mouseCageFrame[num25] >= 4 && mouseCageFrame[num25] <= 7)
            {
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrameCounter[num25] = 0;
                    mouseCageFrame[num25]++;
                }
                if (mouseCageFrame[num25] > 7)
                {
                    mouseCageFrame[num25] = 2;
                }
            }
            else if (mouseCageFrame[num25] >= 2 && mouseCageFrame[num25] <= 3)
            {
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrame[num25]++;
                    if (mouseCageFrame[num25] > 3)
                    {
                        mouseCageFrame[num25] = 2;
                    }
                    mouseCageFrameCounter[num25] = 0;
                    if (rand.Next(15) == 0)
                    {
                        mouseCageFrame[num25] = 8;
                    }
                    else if (rand.Next(15) == 0)
                    {
                        mouseCageFrame[num25] = 12;
                    }
                }
            }
            else if (mouseCageFrame[num25] >= 8 && mouseCageFrame[num25] <= 11)
            {
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrameCounter[num25] = 0;
                    mouseCageFrame[num25]++;
                }
                if (mouseCageFrame[num25] > 11)
                {
                    mouseCageFrame[num25] = 0;
                }
            }
            else if (mouseCageFrame[num25] >= 12 && mouseCageFrame[num25] <= 13)
            {
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrameCounter[num25] = 0;
                    mouseCageFrame[num25]++;
                }
            }
            else if (mouseCageFrame[num25] >= 14 && mouseCageFrame[num25] <= 17)
            {
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrameCounter[num25] = 0;
                    mouseCageFrame[num25]++;
                    if (mouseCageFrame[num25] > 17 && rand.Next(20) != 0)
                    {
                        mouseCageFrame[num25] = 14;
                    }
                }
            }
            else
            {
                if (mouseCageFrame[num25] < 18 || mouseCageFrame[num25] > 19)
                {
                    continue;
                }
                mouseCageFrameCounter[num25]++;
                if (mouseCageFrameCounter[num25] >= 5)
                {
                    mouseCageFrameCounter[num25] = 0;
                    mouseCageFrame[num25]++;
                    if (mouseCageFrame[num25] > 19)
                    {
                        mouseCageFrame[num25] = 0;
                    }
                }
            }
        }
        for (int num26 = 0; num26 < cageFrames; num26++)
        {
            wormCageFrameCounter[num26]++;
            if (wormCageFrameCounter[num26] < rand.Next(30, 91))
            {
                continue;
            }
            wormCageFrameCounter[num26] = 0;
            if (rand.Next(4) != 0)
            {
                continue;
            }
            wormCageFrame[num26]++;
            if (wormCageFrame[num26] == 9 && rand.Next(2) == 0)
            {
                wormCageFrame[num26] = 0;
            }
            if (wormCageFrame[num26] > 18)
            {
                if (rand.Next(2) == 0)
                {
                    wormCageFrame[num26] = 9;
                }
                else
                {
                    wormCageFrame[num26] = 0;
                }
            }
        }
        int num27 = 0;
        for (int num28 = 0; num28 < 3; num28++)
        {
            switch (num28)
            {
            case 0:
                num27 = 24;
                break;
            case 1:
                num27 = 31;
                break;
            case 2:
                num27 = 34;
                break;
            }
            for (int num29 = 0; num29 < cageFrames; num29++)
            {
                if (++slugCageFrameCounter[num28, num29] >= rand.Next(5, 15))
                {
                    slugCageFrameCounter[num28, num29] = 0;
                    if (++slugCageFrame[num28, num29] >= num27)
                    {
                        slugCageFrame[num28, num29] = 0;
                    }
                }
            }
        }
        for (int num30 = 0; num30 < cageFrames; num30++)
        {
            if (grasshopperCageFrame[num30] >= 0 && grasshopperCageFrame[num30] <= 1)
            {
                grasshopperCageFrameCounter[num30]++;
                if (grasshopperCageFrameCounter[num30] >= 5)
                {
                    grasshopperCageFrame[num30]++;
                    if (grasshopperCageFrame[num30] > 1)
                    {
                        grasshopperCageFrame[num30] = 0;
                    }
                    grasshopperCageFrameCounter[num30] = 0;
                    if (rand.Next(15) == 0)
                    {
                        grasshopperCageFrame[num30] = 2;
                    }
                }
            }
            else if (grasshopperCageFrame[num30] >= 2 && grasshopperCageFrame[num30] <= 5)
            {
                grasshopperCageFrameCounter[num30]++;
                if (grasshopperCageFrameCounter[num30] >= 5)
                {
                    grasshopperCageFrameCounter[num30] = 0;
                    grasshopperCageFrame[num30]++;
                }
                if (grasshopperCageFrame[num30] > 5)
                {
                    grasshopperCageFrame[num30] = 6;
                }
            }
            else if (grasshopperCageFrame[num30] >= 6 && grasshopperCageFrame[num30] <= 7)
            {
                grasshopperCageFrameCounter[num30]++;
                if (grasshopperCageFrameCounter[num30] >= 5)
                {
                    grasshopperCageFrame[num30]++;
                    if (grasshopperCageFrame[num30] > 7)
                    {
                        grasshopperCageFrame[num30] = 6;
                    }
                    grasshopperCageFrameCounter[num30] = 0;
                    if (rand.Next(15) == 0)
                    {
                        grasshopperCageFrame[num30] = 8;
                    }
                }
            }
            else if (grasshopperCageFrame[num30] >= 8 && grasshopperCageFrame[num30] <= 11)
            {
                grasshopperCageFrameCounter[num30]++;
                if (grasshopperCageFrameCounter[num30] >= 5)
                {
                    grasshopperCageFrameCounter[num30] = 0;
                    grasshopperCageFrame[num30]++;
                }
                if (grasshopperCageFrame[num30] > 11)
                {
                    grasshopperCageFrame[num30] = 0;
                }
            }
        }
        for (int num31 = 0; num31 < cageFrames; num31++)
        {
            maggotCageFrameCounter[num31]++;
            bool num32 = maggotCageFrame[num31] == 0 || maggotCageFrame[num31] == 6 || maggotCageFrame[num31] == 18;
            int num33 = 8;
            if (num32)
            {
                num33 = rand.Next(100, 140);
            }
            if (maggotCageFrameCounter[num31] < num33)
            {
                continue;
            }
            maggotCageFrameCounter[num31] = 0;
            if (maggotCageFrame[num31] == 0)
            {
                if (rand.Next(3) == 0)
                {
                    maggotCageFrame[num31] = 13;
                }
                else
                {
                    maggotCageFrame[num31] = 1;
                }
                continue;
            }
            if (maggotCageFrame[num31] == 12)
            {
                maggotCageFrame[num31] = 0;
                continue;
            }
            maggotCageFrame[num31]++;
            if (maggotCageFrame[num31] > 23)
            {
                maggotCageFrame[num31] = 6;
            }
        }
        for (int num34 = 0; num34 < cageFrames; num34++)
        {
            ladybugCageFrameCounter[num34]++;
            bool flag6 = ladybugCageFrame[num34] == 3 || ladybugCageFrame[num34] == 7 || ladybugCageFrame[num34] >= 17;
            int num35 = rand.Next(10, 12);
            if (ladybugCageFrame[num34] == 18)
            {
                num35 = rand.Next(160, 241);
            }
            else if (flag6)
            {
                num35 = rand.Next(198, 206);
            }
            else if (ladybugCageFrame[num34] >= 8 && ladybugCageFrame[num34] <= 16)
            {
                num35 = 5;
            }
            if (ladybugCageFrameCounter[num34] < num35)
            {
                continue;
            }
            ladybugCageFrameCounter[num34] = 0;
            if (ladybugCageFrame[num34] < 18)
            {
                if ((ladybugCageFrame[num34] == 2 || ladybugCageFrame[num34] == 5) && rand.Next(3) == 0)
                {
                    ladybugCageFrame[num34] = 17;
                }
                else if (ladybugCageFrame[num34] == 3 || ladybugCageFrame[num34] == 12)
                {
                    switch (rand.Next(3))
                    {
                    case 0:
                    case 1:
                        ladybugCageFrame[num34] = 4;
                        break;
                    case 2:
                        ladybugCageFrame[num34] = 13;
                        break;
                    }
                }
                else if (ladybugCageFrame[num34] == 7 || ladybugCageFrame[num34] == 16)
                {
                    switch (rand.Next(3))
                    {
                    case 0:
                    case 1:
                        ladybugCageFrame[num34] = 0;
                        break;
                    case 2:
                        ladybugCageFrame[num34] = 8;
                        break;
                    }
                }
                else
                {
                    ladybugCageFrame[num34]++;
                }
            }
            else
            {
                ladybugCageFrame[num34] = ((rand.Next(2) == 0) ? 13 : 4);
            }
        }
        for (int num36 = 0; num36 < cageFrames; num36++)
        {
            ratCageFrameCounter[num36]++;
            bool flag7 = ratCageFrame[num36] == 0 || ratCageFrame[num36] == 4;
            bool num37 = ratCageFrame[num36] == 8 || ratCageFrame[num36] == 9 || ratCageFrame[num36] == 10 || ratCageFrame[num36] == 11;
            bool flag8 = ratCageFrame[num36] > 11;
            int num38 = 5;
            if (flag7)
            {
                num38 = rand.Next(40, 70);
            }
            if (num37)
            {
                num38 = rand.Next(70, 110);
            }
            if (flag8)
            {
                num38 = 180;
            }
            if (ratCageFrameCounter[num36] >= num38)
            {
                ratCageFrameCounter[num36] = 0;
                if (ratCageFrame[num36] == 0 && rand.Next(2) == 0)
                {
                    if (rand.Next(3) != 0)
                    {
                        ratCageFrame[num36] = 12;
                    }
                    else
                    {
                        ratCageFrame[num36] = 8;
                    }
                    continue;
                }
                if (ratCageFrame[num36] == 4 && rand.Next(2) == 0)
                {
                    ratCageFrame[num36] = 10;
                    continue;
                }
                if (ratCageFrame[num36] == 7 || ratCageFrame[num36] == 9 || ratCageFrame[num36] == 12)
                {
                    ratCageFrame[num36] = 0;
                    continue;
                }
                if (ratCageFrame[num36] == 11)
                {
                    ratCageFrame[num36] = 4;
                    continue;
                }
                ratCageFrame[num36]++;
                if (ratCageFrame[num36] > 16)
                {
                    ratCageFrame[num36] = 0;
                }
            }
            else if (ratCageFrame[num36] > 11)
            {
                int num39 = ratCageFrameCounter[num36] % 90;
                if (num39 > 80)
                {
                    ratCageFrame[num36] = 12;
                }
                else if (num39 > 70)
                {
                    ratCageFrame[num36] = 13;
                }
                else if (num39 > 60)
                {
                    ratCageFrame[num36] = 14;
                }
                else if (num39 > 50)
                {
                    ratCageFrame[num36] = 15;
                }
                else if (num39 > 40)
                {
                    ratCageFrame[num36] = 16;
                }
                else if (num39 > 30)
                {
                    ratCageFrame[num36] = 15;
                }
                else if (num39 > 20)
                {
                    ratCageFrame[num36] = 14;
                }
                else if (num39 > 10)
                {
                    ratCageFrame[num36] = 13;
                }
                else
                {
                    ratCageFrame[num36] = 12;
                }
            }
            else if (ratCageFrameCounter[num36] % 10 == 0)
            {
                if (ratCageFrame[num36] == 8 || ratCageFrame[num36] == 10)
                {
                    ratCageFrame[num36]++;
                }
                else if (ratCageFrame[num36] == 9 || ratCageFrame[num36] == 11)
                {
                    ratCageFrame[num36]--;
                }
            }
        }
        for (int num40 = 0; num40 < cageFrames; num40++)
        {
            waterStriderCageFrameCounter[num40]++;
            bool flag9 = waterStriderCageFrame[num40] == 0 || waterStriderCageFrame[num40] == 8;
            bool num41 = waterStriderCageFrame[num40] == 17 || waterStriderCageFrame[num40] == 20;
            int num42 = 5;
            if (flag9)
            {
                num42 = rand.Next(110, 210);
            }
            if (num41)
            {
                num42 = rand.Next(150, 260);
            }
            if (waterStriderCageFrameCounter[num40] < num42)
            {
                continue;
            }
            waterStriderCageFrameCounter[num40] = 0;
            if (waterStriderCageFrame[num40] == 0 && rand.Next(2) == 0)
            {
                waterStriderCageFrame[num40] = 16;
                continue;
            }
            if (waterStriderCageFrame[num40] == 8 && rand.Next(2) == 0)
            {
                waterStriderCageFrame[num40] = 19;
                continue;
            }
            if (waterStriderCageFrame[num40] == 15 || waterStriderCageFrame[num40] == 18)
            {
                waterStriderCageFrame[num40] = 0;
                continue;
            }
            waterStriderCageFrame[num40]++;
            if (waterStriderCageFrame[num40] > 21)
            {
                waterStriderCageFrame[num40] = 8;
            }
        }
        fairyJarFrameCounter[0]++;
        if (fairyJarFrameCounter[0] > 5)
        {
            fairyJarFrameCounter[0] = 0;
            fairyJarFrame[0]++;
            if (fairyJarFrame[0] > 11)
            {
                fairyJarFrame[0] = 0;
            }
        }
        for (int num43 = 1; num43 < cageFrames; num43++)
        {
            int num44 = fairyJarFrame[0] + num43 % 12;
            if (num43 % 2 == 0)
            {
                num44++;
            }
            if (num43 % 5 == 0)
            {
                num44++;
            }
            if (num43 % 8 == 0)
            {
                num44++;
            }
            while (num44 >= 12)
            {
                num44 -= 12;
            }
            fairyJarFrame[num43] = num44;
        }
        for (int num45 = 0; num45 < cageFrames; num45++)
        {
            byte maxValue = 5;
            if (fishBowlFrameMode[num45] == 1)
            {
                if (rand.Next(900) == 0)
                {
                    fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
                }
                fishBowlFrameCounter[num45]++;
                if (fishBowlFrameCounter[num45] < 5)
                {
                    continue;
                }
                fishBowlFrameCounter[num45] = 0;
                if (fishBowlFrame[num45] == 10)
                {
                    if (rand.Next(20) == 0)
                    {
                        fishBowlFrame[num45] = 11;
                        fishBowlFrameMode[num45] = 0;
                    }
                    else
                    {
                        fishBowlFrame[num45] = 1;
                    }
                }
                else
                {
                    fishBowlFrame[num45]++;
                }
            }
            else if (fishBowlFrameMode[num45] == 2)
            {
                if (rand.Next(3600) == 0)
                {
                    fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
                }
                fishBowlFrameCounter[num45]++;
                if (fishBowlFrameCounter[num45] < 20)
                {
                    continue;
                }
                fishBowlFrameCounter[num45] = 0;
                if (fishBowlFrame[num45] == 10)
                {
                    if (rand.Next(20) == 0)
                    {
                        fishBowlFrame[num45] = 11;
                        fishBowlFrameMode[num45] = 0;
                    }
                    else
                    {
                        fishBowlFrame[num45] = 1;
                    }
                }
                else
                {
                    fishBowlFrame[num45]++;
                }
            }
            else if (fishBowlFrameMode[num45] == 3)
            {
                if (rand.Next(3600) == 0)
                {
                    fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
                }
                fishBowlFrameCounter[num45]++;
                if (fishBowlFrameCounter[num45] < rand.Next(5, 3600))
                {
                    continue;
                }
                fishBowlFrameCounter[num45] = 0;
                if (fishBowlFrame[num45] == 10)
                {
                    if (rand.Next(20) == 0)
                    {
                        fishBowlFrame[num45] = 11;
                        fishBowlFrameMode[num45] = 0;
                    }
                    else
                    {
                        fishBowlFrame[num45] = 1;
                    }
                }
                else
                {
                    fishBowlFrame[num45]++;
                }
            }
            else if (fishBowlFrame[num45] <= 10)
            {
                if (rand.Next(3600) == 0)
                {
                    fishBowlFrameMode[num45] = (byte)rand.Next(maxValue);
                }
                fishBowlFrameCounter[num45]++;
                if (fishBowlFrameCounter[num45] < 10)
                {
                    continue;
                }
                fishBowlFrameCounter[num45] = 0;
                if (fishBowlFrame[num45] == 10)
                {
                    if (rand.Next(12) == 0)
                    {
                        fishBowlFrame[num45] = 11;
                    }
                    else
                    {
                        fishBowlFrame[num45] = 1;
                    }
                }
                else
                {
                    fishBowlFrame[num45]++;
                }
            }
            else if (fishBowlFrame[num45] == 12 || fishBowlFrame[num45] == 13)
            {
                fishBowlFrameCounter[num45]++;
                if (fishBowlFrameCounter[num45] < 10)
                {
                    continue;
                }
                fishBowlFrameCounter[num45] = 0;
                fishBowlFrame[num45]++;
                if (fishBowlFrame[num45] > 13)
                {
                    if (rand.Next(20) == 0)
                    {
                        fishBowlFrame[num45] = 14;
                    }
                    else
                    {
                        fishBowlFrame[num45] = 12;
                    }
                }
            }
            else
            {
                if (fishBowlFrame[num45] < 11)
                {
                    continue;
                }
                fishBowlFrameCounter[num45]++;
                if (fishBowlFrameCounter[num45] >= 10)
                {
                    fishBowlFrameCounter[num45] = 0;
                    fishBowlFrame[num45]++;
                    if (fishBowlFrame[num45] > 16)
                    {
                        fishBowlFrame[num45] = 4;
                    }
                }
            }
        }
        for (int num46 = 0; num46 < cageFrames; num46++)
        {
            lavaFishBowlFrameCounter[num46]++;
            if (lavaFishBowlFrameCounter[num46] > 4 + rand.Next(3))
            {
                lavaFishBowlFrameCounter[num46] = 0;
                lavaFishBowlFrame[num46]++;
                if (lavaFishBowlFrame[num46] > 26)
                {
                    lavaFishBowlFrame[num46] = 0;
                }
            }
        }
        for (int num47 = 0; num47 < 9; num47++)
        {
            for (int num48 = 0; num48 < cageFrames; num48++)
            {
                butterflyCageFrameCounter[num47, num48]++;
                if (rand.Next(3600) == 0)
                {
                    butterflyCageMode[num47, num48] = (byte)rand.Next(5);
                    if (rand.Next(2) == 0)
                    {
                        butterflyCageMode[num47, num48] += 10;
                    }
                }
                int num49 = rand.Next(3, 16);
                if (butterflyCageMode[num47, num48] == 1 || butterflyCageMode[num47, num48] == 11)
                {
                    num49 = 3;
                }
                if (butterflyCageMode[num47, num48] == 2 || butterflyCageMode[num47, num48] == 12)
                {
                    num49 = 5;
                }
                if (butterflyCageMode[num47, num48] == 3 || butterflyCageMode[num47, num48] == 13)
                {
                    num49 = 10;
                }
                if (butterflyCageMode[num47, num48] == 4 || butterflyCageMode[num47, num48] == 14)
                {
                    num49 = 15;
                }
                if (butterflyCageMode[num47, num48] >= 10)
                {
                    if (butterflyCageFrame[num47, num48] <= 7)
                    {
                        if (butterflyCageFrameCounter[num47, num48] < num49)
                        {
                            continue;
                        }
                        butterflyCageFrameCounter[num47, num48] = 0;
                        butterflyCageFrame[num47, num48]--;
                        if (butterflyCageFrame[num47, num48] < 0)
                        {
                            butterflyCageFrame[num47, num48] = 7;
                        }
                        if (butterflyCageFrame[num47, num48] != 1 && butterflyCageFrame[num47, num48] != 4 && butterflyCageFrame[num47, num48] != 6)
                        {
                            continue;
                        }
                        if (rand.Next(20) == 0)
                        {
                            butterflyCageFrame[num47, num48] += 8;
                        }
                        else if (rand.Next(6) == 0)
                        {
                            if (butterflyCageMode[num47, num48] >= 10)
                            {
                                butterflyCageMode[num47, num48] -= 10;
                            }
                            else
                            {
                                butterflyCageMode[num47, num48] += 10;
                            }
                        }
                    }
                    else
                    {
                        if (butterflyCageFrameCounter[num47, num48] < num49)
                        {
                            continue;
                        }
                        butterflyCageFrameCounter[num47, num48] = 0;
                        butterflyCageFrame[num47, num48]--;
                        if (butterflyCageFrame[num47, num48] < 8)
                        {
                            butterflyCageFrame[num47, num48] = 14;
                        }
                        if (butterflyCageFrame[num47, num48] != 9 && butterflyCageFrame[num47, num48] != 12 && butterflyCageFrame[num47, num48] != 14)
                        {
                            continue;
                        }
                        if (rand.Next(20) == 0)
                        {
                            butterflyCageFrame[num47, num48] -= 8;
                        }
                        else if (rand.Next(6) == 0)
                        {
                            if (butterflyCageMode[num47, num48] >= 10)
                            {
                                butterflyCageMode[num47, num48] -= 10;
                            }
                            else
                            {
                                butterflyCageMode[num47, num48] += 10;
                            }
                        }
                    }
                }
                else if (butterflyCageFrame[num47, num48] <= 7)
                {
                    if (butterflyCageFrameCounter[num47, num48] >= num49)
                    {
                        butterflyCageFrameCounter[num47, num48] = 0;
                        butterflyCageFrame[num47, num48]++;
                        if (butterflyCageFrame[num47, num48] > 7)
                        {
                            butterflyCageFrame[num47, num48] = 0;
                        }
                        if ((butterflyCageFrame[num47, num48] == 1 || butterflyCageFrame[num47, num48] == 4 || butterflyCageFrame[num47, num48] == 6) && rand.Next(10) == 0)
                        {
                            butterflyCageFrame[num47, num48] += 8;
                        }
                    }
                }
                else if (butterflyCageFrameCounter[num47, num48] >= num49)
                {
                    butterflyCageFrameCounter[num47, num48] = 0;
                    butterflyCageFrame[num47, num48]++;
                    if (butterflyCageFrame[num47, num48] > 15)
                    {
                        butterflyCageFrame[num47, num48] = 8;
                    }
                    if ((butterflyCageFrame[num47, num48] == 9 || butterflyCageFrame[num47, num48] == 12 || butterflyCageFrame[num47, num48] == 14) && rand.Next(10) == 0)
                    {
                        butterflyCageFrame[num47, num48] -= 8;
                    }
                }
            }
        }
        UpdateDragonflyJarFrames();
        for (int num50 = 0; num50 < 3; num50++)
        {
            for (int num51 = 0; num51 < cageFrames; num51++)
            {
                jellyfishCageFrameCounter[num50, num51]++;
                if (jellyfishCageMode[num50, num51] == 0 && rand.Next(1800) == 0)
                {
                    jellyfishCageMode[num50, num51] = 1;
                }
                if (jellyfishCageMode[num50, num51] == 2 && rand.Next(60) == 0)
                {
                    jellyfishCageMode[num50, num51] = 3;
                }
                int num52 = 1;
                if (jellyfishCageMode[num50, num51] == 0)
                {
                    num52 = rand.Next(10, 20);
                }
                if (jellyfishCageMode[num50, num51] == 1)
                {
                    num52 = rand.Next(15, 25);
                }
                if (jellyfishCageMode[num50, num51] == 2)
                {
                    num52 = rand.Next(4, 9);
                }
                if (jellyfishCageMode[num50, num51] == 3)
                {
                    num52 = rand.Next(15, 25);
                }
                if (jellyfishCageMode[num50, num51] == 0 && jellyfishCageFrame[num50, num51] <= 3 && jellyfishCageFrameCounter[num50, num51] >= num52)
                {
                    jellyfishCageFrameCounter[num50, num51] = 0;
                    jellyfishCageFrame[num50, num51]++;
                    if (jellyfishCageFrame[num50, num51] >= 4)
                    {
                        jellyfishCageFrame[num50, num51] = 0;
                    }
                }
                if (jellyfishCageMode[num50, num51] == 1 && jellyfishCageFrame[num50, num51] <= 7 && jellyfishCageFrameCounter[num50, num51] >= num52)
                {
                    jellyfishCageFrameCounter[num50, num51] = 0;
                    jellyfishCageFrame[num50, num51]++;
                    if (jellyfishCageFrame[num50, num51] >= 7)
                    {
                        jellyfishCageMode[num50, num51] = 2;
                    }
                }
                if (jellyfishCageMode[num50, num51] == 2 && jellyfishCageFrame[num50, num51] <= 9 && jellyfishCageFrameCounter[num50, num51] >= num52)
                {
                    jellyfishCageFrameCounter[num50, num51] = 0;
                    jellyfishCageFrame[num50, num51]++;
                    if (jellyfishCageFrame[num50, num51] >= 9)
                    {
                        jellyfishCageFrame[num50, num51] = 7;
                    }
                }
                if (jellyfishCageMode[num50, num51] == 3 && jellyfishCageFrame[num50, num51] <= 10 && jellyfishCageFrameCounter[num50, num51] >= num52)
                {
                    jellyfishCageFrameCounter[num50, num51] = 0;
                    jellyfishCageFrame[num50, num51]++;
                    if (jellyfishCageFrame[num50, num51] >= 10)
                    {
                        jellyfishCageFrame[num50, num51] = 3;
                        jellyfishCageMode[num50, num51] = 0;
                    }
                }
            }
        }
    }
 
    private static void UpdateOwlCageFrames()
    {
        for (int i = 0; i < cageFrames; i++)
        {
            UpdateOwlCageFrame(owlCageFrame, owlCageFrameCounter, i);
        }
    }
 
    private static void UpdateDragonflyJarFrames()
    {
        for (int i = 0; i < dragonflyJarFrameCounter.GetLength(0); i++)
        {
            for (int j = 0; j < cageFrames; j++)
            {
                UpdateDragonflyJarFrame(dragonflyJarFrame, dragonflyJarFrameCounter, i, j);
            }
        }
    }
 
    private static void UpdateOwlCageFrame(int[] frames, int[] frameCounters, int style)
    {
        if (frameCounters[style] % 40 != 0 || rand.Next(80) == 0)
        {
            frameCounters[style]++;
        }
        if ((frameCounters[style] + 1) % 40 == 39)
        {
            frameCounters[style] = 40 * rand.Next(4);
        }
        int num = frameCounters[style] % 40 / 10;
        int num2 = frameCounters[style] / 40;
        int num3 = 0;
        switch (num2)
        {
        case 0:
            if (num == 3)
            {
                num = 1;
            }
            num3 = num;
            break;
        case 1:
            if (num == 3)
            {
                num = 1;
            }
            num3 = 0;
            if (num != 0)
            {
                num3 = 8 - num;
            }
            break;
        case 2:
            num3 = 0;
            if (num != 0)
            {
                num3 = 7 + num;
            }
            break;
        case 3:
            num3 = 0;
            if (num != 0)
            {
                num3 = 11 + num;
            }
            break;
        }
        frames[style] = num3;
    }
 
    private static void UpdateDragonflyJarFrame(int[,] frames, int[,] frameCounters, int style, int variation)
    {
        frameCounters[style, variation]++;
        switch (frames[style, variation])
        {
        case 0:
            if (frameCounters[style, variation] >= 300 && rand.Next(60) == 0)
            {
                frameCounters[style, variation] = 0;
                frames[style, variation] = rand.NextFromList<int>(1, 5, 9);
            }
            break;
        case 1:
        case 5:
        case 9:
            if (frameCounters[style, variation] >= 100)
            {
                frameCounters[style, variation] = 0;
                if (frames[style, variation] == 1)
                {
                    frames[style, variation] = rand.NextFromList<int>(0, 5, 5, 9, 9);
                }
                else
                {
                    frames[style, variation] = 1;
                }
            }
            else if (frameCounters[style, variation] >= 6)
            {
                frameCounters[style, variation] = 0;
                frames[style, variation]++;
            }
            break;
        case 2:
        case 3:
        case 4:
        case 6:
        case 7:
        case 8:
        case 10:
        case 11:
        case 12:
        {
            int num = frames[style, variation] - 1;
            int num2 = num % 4;
            num2--;
            int num3 = frameCounters[style, variation] / 4 % 4;
            if (num3 > 2)
            {
                num3 = 4 - num3;
            }
            int num4 = num - num2 + 1 + num3;
            frames[style, variation] = num4;
            if (frameCounters[style, variation] >= 40 && rand.Next(30) == 0)
            {
                frameCounters[style, variation] = 100;
                frames[style, variation] = num - num2 + 1 - 1;
            }
            break;
        }
        }
    }
 
    public static void DoUpdate_AnimateItemIcons()
    {
        for (int i = 0; i < itemAnimationsRegistered.Count; i++)
        {
            int num = itemAnimationsRegistered[i];
            if (itemAnimations[num] != null)
            {
                itemAnimations[num].Update();
            }
        }
    }
 
    public static void QueueMainThreadAction(Action action)
    {
        _mainThreadActions.Enqueue(action);
    }
 
    private static void ConsumeAllMainThreadActions()
    {
        Action result;
        while (_mainThreadActions.TryDequeue(out result))
        {
            result();
        }
    }
 
    protected override void Update(GameTime gameTime)
    {
        if (!IsEnginePreloaded)
        {
            IsEnginePreloaded = true;
            if (Main.OnEnginePreload != null)
            {
                Main.OnEnginePreload();
            }
        }
        if (!_isDrawingOrUpdating)
        {
            _isDrawingOrUpdating = true;
            DoUpdate(ref gameTime);
            CinematicManager.Instance.Update(gameTime);
            if (netMode == 2)
            {
                for (int i = 0; i < 256; i++)
                {
                    if (Netplay.Clients[i].Socket != null)
                    {
                        Netplay.Clients[i].Socket.SendQueuedPackets();
                    }
                }
            }
            else if (netMode == 1)
            {
                Netplay.Connection.Socket.SendQueuedPackets();
            }
            _isDrawingOrUpdating = false;
        }
        base.Update(gameTime);
        ConsumeAllMainThreadActions();
        if (GameAskedToQuit)
        {
            QuitGame();
        }
    }
 
    public void UpdateViewZoomKeys()
    {
        if (!inFancyUI)
        {
            float num = 0.02f;
            if (PlayerInput.Triggers.Current.ViewZoomIn)
            {
                GameZoomTarget = Utils.Clamp(GameZoomTarget + num, 1f, 2f);
            }
            if (PlayerInput.Triggers.Current.ViewZoomOut)
            {
                GameZoomTarget = Utils.Clamp(GameZoomTarget - num, 1f, 2f);
            }
        }
    }
 
    public static void NotifyOfEvent(GameNotificationType type)
    {
        if (!dedServ && !instance.IsActive && _flashNotificationType.HasFlag(type))
        {
            QueueMainThreadAction(delegate
            {
                Platform.Get<IWindowService>().StartFlashingIcon(instance.Window);
            });
        }
    }
 
    protected void DoUpdate(ref GameTime gameTime)
    {
        gameTimeCache = gameTime;
        if (showSplash)
        {
            UpdateAudio();
            GlobalTimeWrappedHourly = (float)(gameTime.TotalGameTime.TotalSeconds % 3600.0);
            ChromaInitializer.UpdateEvents();
            Chroma.Update(GlobalTimeWrappedHourly);
            return;
        }
        PartySky.MultipleSkyWorkaroundFix = true;
        LocalPlayer.cursorItemIconReversed = false;
        if (!GlobalTimerPaused)
        {
            GlobalTimeWrappedHourly = (float)(gameTime.TotalGameTime.TotalSeconds % 3600.0);
        }
        UpdateCreativeGameModeOverride();
        UpdateWorldPreparationState();
        if (Player.BlockInteractionWithProjectiles > 0 && !mouseRight && mouseRightRelease)
        {
            Player.BlockInteractionWithProjectiles--;
        }
        PlayerInput.SetZoom_UI();
        for (int num = DelayedProcesses.Count - 1; num >= 0; num--)
        {
            IEnumerator enumerator = DelayedProcesses[num];
            if (!enumerator.MoveNext())
            {
                DelayedProcesses.Remove(enumerator);
            }
        }
        if (!gameMenu || menuMode != 888)
        {
            MenuUI.SetState(null);
        }
        else
        {
            InGameUI.SetState(null);
        }
        CurrentInputTextTakerOverride = null;
        if (!dedServ)
        {
            AchievementAdvisor.Update();
        }
        PlayerInput.SetZoom_Unscaled();
        MouseOversTryToClear();
        PlayerInput.ResetInputsOnActiveStateChange();
        if (!dedServ && Main.OnTickForThirdPartySoftwareOnly != null)
        {
            Main.OnTickForThirdPartySoftwareOnly();
        }
        if (_hasPendingNetmodeChange)
        {
            netMode = _targetNetMode;
            _hasPendingNetmodeChange = false;
        }
        if (CaptureManager.Instance.IsCapturing)
        {
            return;
        }
        if (ActivePlayerFileData != null)
        {
            ActivePlayerFileData.UpdatePlayTimer();
        }
        Netplay.UpdateInMainThread();
        gameInactive = !base.IsActive;
        if (changeTheTitle)
        {
            changeTheTitle = false;
            SetTitle();
        }
        _worldUpdateTimeTester.Restart();
        if (!WorldGen.gen)
        {
            WorldGen.destroyObject = false;
        }
        if (gameMenu)
        {
            mapFullscreen = false;
        }
        UpdateSettingUnlocks();
        if (dedServ)
        {
            if (dedServFPS)
            {
                updatesCountedForFPS++;
                if (!fpsTimer.IsRunning)
                {
                    fpsTimer.Restart();
                }
                if (fpsTimer.ElapsedMilliseconds >= 1000)
                {
                    dedServCount1 += updatesCountedForFPS;
                    dedServCount2++;
                    float num2 = (float)dedServCount1 / (float)dedServCount2;
                    Console.WriteLine(updatesCountedForFPS + "  (" + num2 + ")");
                    updatesCountedForFPS = 0;
                    fpsTimer.Restart();
                }
            }
            else
            {
                if (fpsTimer.IsRunning)
                {
                    fpsTimer.Stop();
                }
                updatesCountedForFPS = 0;
            }
        }
        DoUpdate_AutoSave();
        if (!dedServ)
        {
            ChromaInitializer.UpdateEvents();
            Chroma.Update(GlobalTimeWrappedHourly);
            if (superFast)
            {
                base.IsFixedTimeStep = false;
                graphics.SynchronizeWithVerticalRetrace = false;
            }
            else
            {
                if (FrameSkipMode == FrameSkipMode.Off || FrameSkipMode == FrameSkipMode.Subtle)
                {
                    if (base.IsActive)
                    {
                        base.IsFixedTimeStep = false;
                    }
                    else
                    {
                        base.IsFixedTimeStep = true;
                    }
                }
                else
                {
                    base.IsFixedTimeStep = true;
                    graphics.SynchronizeWithVerticalRetrace = true;
                }
                graphics.SynchronizeWithVerticalRetrace = true;
            }
            if (showSplash)
            {
                return;
            }
            updatesCountedForFPS++;
            if (fpsTimer.ElapsedMilliseconds >= 1000)
            {
                if ((float)fpsCount >= 30f + 30f * gfxQuality)
                {
                    gfxQuality += gfxRate;
                    gfxRate += 0.005f;
                }
                else if ((float)fpsCount < 29f + 30f * gfxQuality)
                {
                    gfxRate = 0.01f;
                    gfxQuality -= 0.1f;
                }
                if (gfxQuality < 0f)
                {
                    gfxQuality = 0f;
                }
                if (gfxQuality > 1f)
                {
                    gfxQuality = 1f;
                }
                if (maxQ && base.IsActive)
                {
                    gfxQuality = 1f;
                    maxQ = false;
                }
                updateRate = uCount;
                frameRate = fpsCount;
                fpsCount = 0;
                fpsTimer.Restart();
                updatesCountedForFPS = 0;
                drawsCountedForFPS = 0;
                uCount = 0;
                if (gfxQuality < 0.8f)
                {
                    mapTimeMax = (int)((1f - gfxQuality) * 60f);
                }
                else
                {
                    mapTimeMax = 0;
                }
            }
            if (FrameSkipMode == FrameSkipMode.Off || FrameSkipMode == FrameSkipMode.Subtle)
            {
                UpdateTimeAccumulator += gameTime.ElapsedGameTime.TotalSeconds;
                if (UpdateTimeAccumulator < 0.01666666753590107 && !superFast)
                {
                    if (FrameSkipMode == FrameSkipMode.Subtle)
                    {
                        instance.SuppressDraw();
                    }
                    return;
                }
                gameTime = new GameTime(gameTime.TotalGameTime, new TimeSpan(166666L));
                UpdateTimeAccumulator -= 0.01666666753590107;
                UpdateTimeAccumulator = Math.Min(UpdateTimeAccumulator, 0.01666666753590107);
            }
            uCount++;
            drawSkip = false;
            PlayerInput.AllowExecutionOfGamepadInstructions = true;
            TryPlayingCreditsRoll();
            PlayerInput.SetZoom_UI();
            UpdateUIStates(gameTime);
            PlayerInput.SetZoom_Unscaled();
            Terraria.Graphics.Effects.Filters.Scene.Update(gameTime);
            Overlays.Scene.Update(gameTime);
            LiquidRenderer.Instance.Update(gameTime);
            UpdateAudio();
            InGameNotificationsTracker.Update();
            ItemSlot.UpdateInterface();
            if (teamCooldown > 0)
            {
                teamCooldown--;
            }
            DoUpdate_AnimateBackgrounds();
            Animation.UpdateAll();
            if (qaStyle == 1)
            {
                gfxQuality = 1f;
            }
            else if (qaStyle == 2)
            {
                gfxQuality = 0.5f;
            }
            else if (qaStyle == 3)
            {
                gfxQuality = 0f;
            }
            maxDustToDraw = (int)(6000f * (gfxQuality * 0.7f + 0.3f));
            if ((double)gfxQuality < 0.9)
            {
                maxDustToDraw = (int)((float)maxDustToDraw * gfxQuality);
            }
            if (maxDustToDraw < 1000)
            {
                maxDustToDraw = 1000;
            }
            Gore.goreTime = (int)(600f * gfxQuality);
            if (!WorldGen.gen)
            {
                Liquid.cycles = (int)(17f - 10f * gfxQuality);
                Liquid.curMaxLiquid = (int)((double)Liquid.maxLiquid * 0.25 + (double)Liquid.maxLiquid * 0.75 * (double)gfxQuality);
                if (Setting_UseReducedMaxLiquids)
                {
                    Liquid.curMaxLiquid = (int)(2500f + 2500f * gfxQuality);
                }
            }
            if (superFast)
            {
                graphics.SynchronizeWithVerticalRetrace = false;
                drawSkip = false;
            }
            if ((double)gfxQuality < 0.2)
            {
                LegacyLighting.RenderPhases = 8;
            }
            else if ((double)gfxQuality < 0.4)
            {
                LegacyLighting.RenderPhases = 7;
            }
            else if ((double)gfxQuality < 0.6)
            {
                LegacyLighting.RenderPhases = 6;
            }
            else if ((double)gfxQuality < 0.8)
            {
                LegacyLighting.RenderPhases = 5;
            }
            else
            {
                LegacyLighting.RenderPhases = 4;
            }
            if (!WorldGen.gen && Liquid.quickSettle)
            {
                Liquid.curMaxLiquid = Liquid.maxLiquid;
                if (Setting_UseReducedMaxLiquids)
                {
                    Liquid.curMaxLiquid = 5000;
                }
                Liquid.cycles = 1;
            }
            if (WorldGen.tenthAnniversaryWorldGen && !gameMenu)
            {
                WorldGen.tenthAnniversaryWorldGen = false;
            }
            if (WorldGen.drunkWorldGen || WorldGen.remixWorldGen)
            {
                if (!gameMenu)
                {
                    WorldGen.drunkWorldGen = false;
                    WorldGen.remixWorldGen = false;
                    logoRotation = 0f;
                    logoRotationSpeed = 0f;
                    logoScale = 1f;
                }
            }
            else if (gameMenu && Math.Abs(logoRotationSpeed) > 1000f)
            {
                logoRotation = 0f;
                logoRotationSpeed = 0f;
                logoScale = 1f;
            }
            UpdateOldNPCShop();
            hasFocus = base.IsActive;
            if (Platform.IsWindows)
            {
                Form form = Control.FromHandle(base.Window.Handle) as Form;
                bool num3 = form.WindowState == FormWindowState.Minimized;
                bool flag = Form.ActiveForm == form;
                hasFocus |= flag;
                if (num3)
                {
                    hasFocus = false;
                }
            }
            if (!hasFocus && netMode == 0)
            {
                if (!Platform.IsOSX)
                {
                    base.IsMouseVisible = true;
                }
                if (netMode != 2 && myPlayer >= 0)
                {
                    player[myPlayer].delayUseItem = true;
                }
                mouseLeftRelease = false;
                mouseRightRelease = false;
                if (gameMenu)
                {
                    UpdateMenu();
                }
                gamePaused = true;
                return;
            }
            if (!Platform.IsOSX)
            {
                base.IsMouseVisible = false;
            }
            SkyManager.Instance.Update(gameTime);
            if (!gamePaused)
            {
                EmoteBubble.UpdateAll();
            }
            ScreenObstruction.Update();
            ScreenDarkness.Update();
            MoonlordDeathDrama.Update();
            DoUpdate_AnimateCursorColors();
            DoUpdate_AnimateTileGlows();
            DoUpdate_AnimateDiscoRGB();
            DoUpdate_AnimateVisualPlayerAura();
            DoUpdate_AnimateWaterfalls();
            DoUpdate_AnimateWalls();
            AnimateTiles();
            DoUpdate_AnimateItemIcons();
            DoUpdate_F10_ToggleFPS();
            DoUpdate_F9_ToggleLighting();
            DoUpdate_F8_ToggleNetDiagnostics();
            DoUpdate_F7_ToggleGraphicsDiagnostics();
            DoUpdate_F11_ToggleUI();
            DoUpdate_AltEnter_ToggleFullscreen();
            DoUpdate_HandleInput();
            DoUpdate_HandleChat();
            DoUpdate_Enter_ToggleChat();
            if ((timeForVisualEffects += 1.0) >= 216000.0)
            {
                timeForVisualEffects = 0.0;
            }
            if (gameMenu)
            {
                UpdateMenu();
                if (netMode != 2)
                {
                    return;
                }
                gamePaused = false;
            }
            if (!CanUpdateGameplay && netMode != 2)
            {
                return;
            }
            CheckInvasionProgressDisplay();
        }
        UpdateWindyDayState();
        if (netMode == 2)
        {
            cloudAlpha = maxRaining;
        }
        bool flag2 = base.IsActive;
        if (netMode == 1)
        {
            TrySyncingMyPlayer();
        }
        if (CanPauseGame())
        {
            DoUpdate_WhilePaused();
            gamePaused = true;
            return;
        }
        gamePaused = false;
        if (Main.OnTickForInternalCodeOnly != null)
        {
            Main.OnTickForInternalCodeOnly();
        }
        if ((dedServ || (netMode != 1 && !gameMenu && !gamePaused)) && AmbienceServer != null)
        {
            AmbienceServer.Update();
        }
        WorldGen.BackgroundsCache.UpdateFlashValues();
        if (LocalGolfState != null)
        {
            LocalGolfState.Update();
        }
        if ((flag2 || netMode == 1) && cloudAlpha > 0f)
        {
            Rain.MakeRain();
        }
        if (netMode != 1)
        {
            updateCloudLayer();
        }
        for (int i = 0; i < dayRate; i++)
        {
            UpdateWeather(gameTime, i);
        }
        UnpausedUpdateSeed = Utils.RandomNextSeed(UnpausedUpdateSeed);
        Ambience();
        if (netMode != 2)
        {
            try
            {
                snowing();
            }
            catch
            {
                if (!ignoreErrors)
                {
                    throw;
                }
            }
            Sandstorm.EmitDust();
        }
        if (netMode != 2)
        {
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                Star.UpdateStars();
                Cloud.UpdateClouds();
            }
            else if (shimmerAlpha > 0f)
            {
                Star.UpdateStars();
                int num4 = rand.Next(numStars);
                if (rand.Next(90) == 0)
                {
                    if (star[num4] != null && !star[num4].hidden && !star[num4].falling)
                    {
                        star[num4].Fall();
                    }
                    for (int j = 0; j < numStars; j++)
                    {
                        if (star[j].hidden)
                        {
                            Star.SpawnStars(j);
                        }
                    }
                }
            }
        }
        PortalHelper.UpdatePortalPoints();
        LucyAxeMessage.UpdateMessageCooldowns();
        if (ShouldUpdateEntities())
        {
            DoUpdateInWorld(_worldUpdateTimeTester);
        }
        if (netMode != 2)
        {
            ChromaPainter.Update();
        }
    }
 
    internal static void UpdateCreativeGameModeOverride()
    {
        _overrideForExpertMode = null;
        _overrideForMasterMode = null;
        if (gameMenu || !_currentGameModeInfo.IsJourneyMode)
        {
            return;
        }
        CreativePowers.DifficultySliderPower power = CreativePowerManager.Instance.GetPower<CreativePowers.DifficultySliderPower>();
        if (power.GetIsUnlocked())
        {
            float num = power.StrengthMultiplierToGiveNPCs;
            if (getGoodWorld)
            {
                num += 1f;
            }
            if (num >= 2f)
            {
                _overrideForExpertMode = true;
            }
            if (num >= 3f)
            {
                _overrideForMasterMode = true;
            }
        }
    }
 
    private static void TryPlayingCreditsRoll()
    {
        if (!gameMenu && CanPlayCreditsRoll() && !SkyManager.Instance["CreditsRoll"].IsActive())
        {
            SkyManager.Instance.Activate("CreditsRoll", Vector2.Zero);
        }
    }
 
    private static bool CanPauseGame()
    {
        bool flag = false;
        if (netMode == 0)
        {
            flag |= ingameOptionsWindow;
            flag |= InGameUI.IsVisible && (InGameUI.CurrentState == ManageControlsMenu || InGameUI.CurrentState == AchievementsMenu);
            if (autoPause)
            {
                flag |= playerInventory;
                flag |= LocalPlayer.sign >= 0;
                flag |= InGameUI.IsVisible;
            }
        }
        return flag;
    }
 
    private static void DoUpdate_WhilePaused()
    {
        if (!drawingPlayerChat && !editSign && !editChest && !blockInput)
        {
            Main.player[myPlayer].controlInv = PlayerInput.Triggers.Current.Inventory;
            Main.player[myPlayer].controlCreativeMenu = PlayerInput.Triggers.Current.OpenCreativePowersMenu;
            Player player = Main.player[myPlayer];
            if (player.controlCreativeMenu)
            {
                if (player.releaseCreativeMenu)
                {
                    player.ToggleCreativeMenu();
                }
                player.releaseCreativeMenu = false;
            }
            else
            {
                player.releaseCreativeMenu = true;
            }
            if (player.controlInv)
            {
                if (player.releaseInventory)
                {
                    player.ToggleInv();
                }
                player.releaseInventory = false;
            }
            else
            {
                player.releaseInventory = true;
            }
        }
        if (playerInventory)
        {
            Main.player[myPlayer].RefreshInfoAccs();
            Recipe.GetThroughDelayedFindRecipes();
            int num = PlayerInput.ScrollWheelDelta / 120;
            bool flag = true;
            if (recBigList)
            {
                int num2 = 42;
                int num3 = 340;
                int num4 = 310;
                PlayerInput.SetZoom_UI();
                int num5 = (screenWidth - num4 - 280) / num2;
                int num6 = (screenHeight - num3 - 20) / num2;
                if (new Microsoft.Xna.Framework.Rectangle(num4, num3, num5 * num2, num6 * num2).Contains(MouseScreen.ToPoint()))
                {
                    int num7 = Math.Sign(num);
                    while (num != 0)
                    {
                        if (num < 0)
                        {
                            recStart -= num5;
                            if (recStart < 0)
                            {
                                recStart = 0;
                            }
                        }
                        else
                        {
                            recStart += num5;
                            SoundEngine.PlaySound(12);
                            if (recStart > numAvailableRecipes - num5)
                            {
                                recStart = numAvailableRecipes - num5;
                            }
                        }
                        num -= num7;
                    }
                }
                PlayerInput.SetZoom_World();
            }
            if (flag)
            {
                focusRecipe += num;
                if (focusRecipe > numAvailableRecipes - 1)
                {
                    focusRecipe = numAvailableRecipes - 1;
                }
                if (focusRecipe < 0)
                {
                    focusRecipe = 0;
                }
            }
            Main.player[myPlayer].dropItemCheck();
        }
        Main.player[myPlayer].head = Main.player[myPlayer].armor[0].headSlot;
        Main.player[myPlayer].body = Main.player[myPlayer].armor[1].bodySlot;
        Main.player[myPlayer].legs = Main.player[myPlayer].armor[2].legSlot;
        if (!Main.player[myPlayer].hostile)
        {
            if (Main.player[myPlayer].armor[10].headSlot >= 0)
            {
                Main.player[myPlayer].head = Main.player[myPlayer].armor[10].headSlot;
            }
            if (Main.player[myPlayer].armor[11].bodySlot >= 0)
            {
                Main.player[myPlayer].body = Main.player[myPlayer].armor[11].bodySlot;
            }
            if (Main.player[myPlayer].armor[12].legSlot >= 0)
            {
                Main.player[myPlayer].legs = Main.player[myPlayer].armor[12].legSlot;
            }
        }
        if (editSign)
        {
            if (Main.player[myPlayer].sign == -1)
            {
                editSign = false;
            }
            else
            {
                InputTextSign();
            }
        }
        else if (editChest && Main.player[myPlayer].chest == -1)
        {
            editChest = false;
        }
        Player.tileTargetX = (int)(((float)mouseX + screenPosition.X) / 16f);
        Player.tileTargetY = (int)(((float)mouseY + screenPosition.Y) / 16f);
        Main.player[myPlayer].LookForTileInteractions();
        Main.player[myPlayer].lastChest = Main.player[myPlayer].chest;
        if (playerInventory)
        {
            Main.player[myPlayer].AdjTiles();
        }
    }
 
    private static void UpdateUIStates(GameTime gameTime)
    {
        if (MenuUI != null)
        {
            MenuUI.Update(gameTime);
        }
        if (InGameUI != null)
        {
            InGameUI.Update(gameTime);
        }
        CreativeMenu.Update(gameTime);
        BigBossProgressBar.Update();
    }
 
    private void DoDebugFunctions()
    {
    }
 
    private void PreUpdateAllProjectiles()
    {
        SpelunkerProjectileHelper.OnPreUpdateAllProjectiles();
        ChumBucketProjectileHelper.OnPreUpdateAllProjectiles();
    }
 
    private void PostUpdateAllProjectiles()
    {
    }
 
    private static void TrySyncingMyPlayer()
    {
        Player player = clientPlayer;
        bool syncedAnyInventoryContents = false;
        for (int i = 0; i < 59; i++)
        {
            if (Main.player[myPlayer].inventory[i].IsNotTheSameAs(player.inventory[i]))
            {
                syncedAnyInventoryContents = true;
                NetMessage.SendData(5, -1, -1, null, myPlayer, PlayerItemSlotID.Inventory0 + i, (int)Main.player[myPlayer].inventory[i].prefix);
            }
        }
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].armor, player.armor, PlayerItemSlotID.Armor0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].dye, player.dye, PlayerItemSlotID.Dye0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].miscEquips, player.miscEquips, PlayerItemSlotID.Misc0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].miscDyes, player.miscDyes, PlayerItemSlotID.MiscDye0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].bank.item, player.bank.item, PlayerItemSlotID.Bank1_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].bank2.item, player.bank2.item, PlayerItemSlotID.Bank2_0);
        if (Main.player[myPlayer].trashItem.IsNotTheSameAs(player.trashItem))
        {
            syncedAnyInventoryContents = true;
            NetMessage.SendData(5, -1, -1, null, myPlayer, PlayerItemSlotID.TrashItem, (int)Main.player[myPlayer].trashItem.prefix);
        }
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].bank3.item, player.bank3.item, PlayerItemSlotID.Bank3_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].bank4.item, player.bank4.item, PlayerItemSlotID.Bank4_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].Loadouts[0].Armor, player.Loadouts[0].Armor, PlayerItemSlotID.Loadout1_Armor_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].Loadouts[0].Dye, player.Loadouts[0].Dye, PlayerItemSlotID.Loadout1_Dye_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].Loadouts[1].Armor, player.Loadouts[1].Armor, PlayerItemSlotID.Loadout2_Armor_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].Loadouts[1].Dye, player.Loadouts[1].Dye, PlayerItemSlotID.Loadout2_Dye_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].Loadouts[2].Armor, player.Loadouts[2].Armor, PlayerItemSlotID.Loadout3_Armor_0);
        TrySyncingItemArray(ref syncedAnyInventoryContents, Main.player[myPlayer].Loadouts[2].Dye, player.Loadouts[2].Dye, PlayerItemSlotID.Loadout3_Dye_0);
        if (Main.player[myPlayer].chest != player.chest && Main.player[myPlayer].chest < 0 && player.chest >= 0)
        {
            if (Main.player[myPlayer].editedChestName)
            {
                if (chest[player.chest] != null)
                {
                    NetMessage.SendData(33, -1, -1, NetworkText.FromLiteral(chest[player.chest].name), Main.player[myPlayer].chest, 1f);
                }
                else
                {
                    NetMessage.SendData(33, -1, -1, null, Main.player[myPlayer].chest);
                }
                Main.player[myPlayer].editedChestName = false;
            }
            else
            {
                NetMessage.SendData(33, -1, -1, null, Main.player[myPlayer].chest);
            }
        }
        if (Main.player[myPlayer].talkNPC != player.talkNPC)
        {
            NetMessage.SendData(40, -1, -1, null, myPlayer);
        }
        if (false | (Main.player[myPlayer].voidLensChest != player.voidLensChest) | (Main.player[myPlayer].piggyBankProjTracker != player.piggyBankProjTracker))
        {
            NetMessage.SendData(142, -1, -1, null, myPlayer);
        }
        if (LocalPlayer.tileEntityAnchor.interactEntityID != player.tileEntityAnchor.interactEntityID && LocalPlayer.tileEntityAnchor.interactEntityID < 0)
        {
            NetMessage.SendData(122, -1, -1, null, -1, myPlayer);
        }
        bool flag = false;
        if ((byte)Main.player[myPlayer].zone1 != (byte)player.zone1)
        {
            flag = true;
        }
        if ((byte)Main.player[myPlayer].zone2 != (byte)player.zone2)
        {
            flag = true;
        }
        if ((byte)Main.player[myPlayer].zone3 != (byte)player.zone3)
        {
            flag = true;
        }
        if ((byte)Main.player[myPlayer].zone4 != (byte)player.zone4)
        {
            flag = true;
        }
        if ((byte)Main.player[myPlayer].zone5 != (byte)player.zone5)
        {
            flag = true;
        }
        if (flag)
        {
            NetMessage.SendData(36, -1, -1, null, myPlayer);
        }
        if (Main.player[myPlayer].statLife != player.statLife || Main.player[myPlayer].statLifeMax != player.statLifeMax)
        {
            Main.player[myPlayer].netLife = true;
        }
        if (Main.player[myPlayer].netLifeTime > 0)
        {
            Main.player[myPlayer].netLifeTime--;
        }
        else if (Main.player[myPlayer].netLife)
        {
            Main.player[myPlayer].netLife = false;
            Main.player[myPlayer].netLifeTime = 60;
            NetMessage.SendData(16, -1, -1, null, myPlayer);
        }
        if (Main.player[myPlayer].statMana != player.statMana || Main.player[myPlayer].statManaMax != player.statManaMax)
        {
            Main.player[myPlayer].netMana = true;
        }
        if (Main.player[myPlayer].netManaTime > 0)
        {
            Main.player[myPlayer].netManaTime--;
        }
        else if (Main.player[myPlayer].netMana)
        {
            Main.player[myPlayer].netMana = false;
            Main.player[myPlayer].netManaTime = 60;
            NetMessage.SendData(42, -1, -1, null, myPlayer);
        }
        bool flag2 = false;
        for (int j = 0; j < Player.maxBuffs; j++)
        {
            if (Main.player[myPlayer].buffType[j] != player.buffType[j])
            {
                flag2 = true;
                break;
            }
        }
        if (flag2)
        {
            NetMessage.SendData(50, -1, -1, null, myPlayer);
            NetMessage.SendData(13, -1, -1, null, myPlayer);
        }
        bool flag3 = false;
        if (Main.player[myPlayer].MinionRestTargetPoint != player.MinionRestTargetPoint)
        {
            flag3 = true;
        }
        if (flag3)
        {
            NetMessage.SendData(99, -1, -1, null, myPlayer);
        }
        bool flag4 = false;
        if (Main.player[myPlayer].MinionAttackTargetNPC != player.MinionAttackTargetNPC)
        {
            flag4 = true;
        }
        if (flag4)
        {
            NetMessage.SendData(115, -1, -1, null, myPlayer);
        }
        if (player.shieldRaised != Main.player[myPlayer].shieldRaised)
        {
            NetMessage.SendData(13, -1, -1, null, myPlayer);
        }
        if (syncedAnyInventoryContents)
        {
            NetMessage.SendData(138);
        }
        clientPlayer = Main.player[myPlayer].clientClone();
    }
 
    private static void TrySyncingItemArray(ref bool syncedAnyInventoryContents, Item[] my, Item[] other, int slotOffset)
    {
        for (int i = 0; i < my.Length; i++)
        {
            if (my[i].IsNotTheSameAs(other[i]))
            {
                syncedAnyInventoryContents = true;
                NetMessage.SendData(5, -1, -1, null, myPlayer, slotOffset + i, (int)my[i].prefix);
            }
        }
    }
 
    public bool ShouldUpdateEntities()
    {
        return _worldPreparationState == WorldPreparationState.Ready;
    }
 
    private void DoUpdateInWorld(Stopwatch sw)
    {
        UpdateParticleSystems();
        tileSolid[379] = false;
        int num = 0;
        int num2 = 0;
        sittingManager.ClearPlayerAnchors();
        sleepingManager.ClearPlayerAnchors();
        for (int i = 0; i < 255; i++)
        {
            if (!player[i].active)
            {
                continue;
            }
            try
            {
                player[i].Update(i);
                if (player[i].active)
                {
                    num++;
                    if (player[i].sleeping.FullyFallenAsleep)
                    {
                        num2++;
                    }
                }
            }
            catch
            {
                if (!ignoreErrors)
                {
                    throw;
                }
            }
        }
        CurrentFrameFlags.ActivePlayersCount = num;
        CurrentFrameFlags.SleepingPlayersCount = num2;
        if (netMode != 2)
        {
            int num3 = myPlayer;
            if (player[num3].creativeGodMode)
            {
                player[num3].statLife = player[num3].statLifeMax2;
                player[num3].statMana = player[num3].statManaMax2;
                player[num3].breath = player[num3].breathMax;
            }
        }
        _gameUpdateCount++;
        NPC.RevengeManager.Update();
        if (netMode != 1)
        {
            if (remixWorld)
            {
                NPC.SetRemixHax();
            }
            try
            {
                NPC.SpawnNPC();
            }
            catch
            {
            }
            if (remixWorld)
            {
                NPC.ResetRemixHax();
            }
        }
        if (netMode != 1)
        {
            PressurePlateHelper.Update();
        }
        for (int j = 0; j < 255; j++)
        {
            player[j].nearbyActiveNPCs = 0f;
            player[j].townNPCs = 0f;
        }
        CheckBossIndexes();
        sittingManager.ClearNPCAnchors();
        sleepingManager.ClearNPCAnchors();
        NPC.taxCollector = false;
        NPC.ClearFoundActiveNPCs();
        NPC.UpdateFoundActiveNPCs();
        FixExploitManEaters.Update();
        if (netMode != 1)
        {
            BestiaryTracker.Sights.ScanWorldForFinds();
        }
        bool anyActiveBossNPC = false;
        if (NPC.offSetDelayTime > 0)
        {
            NPC.offSetDelayTime--;
        }
        if (remixWorld && NPC.empressRageMode && !NPC.AnyNPCs(636))
        {
            NPC.empressRageMode = false;
        }
        if (netMode != 1 && afterPartyOfDoom && !BirthdayParty.PartyIsUp)
        {
            for (int k = 0; k < 200; k++)
            {
                NPC nPC = npc[k];
                if (nPC.active && nPC.townNPC && nPC.type != 37 && nPC.type != 453 && nPC.type != 368)
                {
                    nPC.StrikeNPCNoInteraction(9999, 10f, -nPC.direction);
                    if (netMode == 2)
                    {
                        NetMessage.SendData(28, -1, -1, null, k, 9999f, 10f, -nPC.direction);
                    }
                }
            }
            NPC.unlockedPartyGirlSpawn = false;
            NPC.unlockedPrincessSpawn = false;
            NPC.unlockedSlimeRainbowSpawn = false;
            NPC.unlockedSlimeGreenSpawn = false;
            afterPartyOfDoom = false;
        }
        if (NPC.brainOfGravity >= 0 && NPC.brainOfGravity < 200 && (!npc[NPC.brainOfGravity].active || npc[NPC.brainOfGravity].type != 266))
        {
            NPC.brainOfGravity = -1;
        }
        for (int l = 0; l < 200; l++)
        {
            if (ignoreErrors)
            {
                try
                {
                    npc[l].UpdateNPC(l);
                    if (npc[l].active && (npc[l].boss || NPCID.Sets.DangerThatPreventsOtherDangers[npc[l].type]))
                    {
                        anyActiveBossNPC = true;
                    }
                }
                catch (Exception)
                {
                    npc[l] = new NPC();
                }
            }
            else
            {
                npc[l].UpdateNPC(l);
            }
        }
        CurrentFrameFlags.AnyActiveBossNPC = anyActiveBossNPC;
        for (int m = 0; m < 600; m++)
        {
            if (ignoreErrors)
            {
                try
                {
                    gore[m].Update();
                }
                catch
                {
                    gore[m] = new Gore();
                }
            }
            else
            {
                gore[m].Update();
            }
        }
        LockOnHelper.SetUP();
        CurrentFrameFlags.HadAnActiveInteractibleProjectile = false;
        PreUpdateAllProjectiles();
        for (int n = 0; n < 1000; n++)
        {
            ProjectileUpdateLoopIndex = n;
            if (ignoreErrors)
            {
                try
                {
                    projectile[n].Update(n);
                }
                catch
                {
                    projectile[n] = new Projectile();
                }
            }
            else
            {
                projectile[n].Update(n);
            }
        }
        ProjectileUpdateLoopIndex = -1;
        PostUpdateAllProjectiles();
        LockOnHelper.SetDOWN();
        Item.numberOfNewItems = 0;
        for (int num4 = 0; num4 < 400; num4++)
        {
            if (ignoreErrors)
            {
                try
                {
                    item[num4].UpdateItem(num4);
                }
                catch
                {
                    item[num4] = new Item();
                }
            }
            else
            {
                item[num4].UpdateItem(num4);
            }
        }
        if (ignoreErrors)
        {
            try
            {
                Dust.UpdateDust();
            }
            catch
            {
                for (int num5 = 0; num5 < 6000; num5++)
                {
                    dust[num5] = new Dust();
                    dust[num5].dustIndex = num5;
                }
            }
        }
        else
        {
            Dust.UpdateDust();
        }
        if (netMode != 2)
        {
            CombatText.UpdateCombatText();
            PopupText.UpdateItemText();
        }
        if (ignoreErrors)
        {
            try
            {
                UpdateTime();
            }
            catch
            {
                checkForSpawns = 0;
            }
        }
        else
        {
            UpdateTime();
        }
        tileSolid[379] = true;
        if (gameMenu && netMode != 2)
        {
            return;
        }
        if (netMode != 1)
        {
            if (ignoreErrors)
            {
                try
                {
                    WorldGen.UpdateWorld();
                    UpdateInvasion();
                }
                catch
                {
                }
            }
            else
            {
                WorldGen.UpdateWorld();
                UpdateInvasion();
            }
        }
        if (ignoreErrors)
        {
            try
            {
                if (netMode == 2)
                {
                    UpdateServer();
                }
                if (netMode == 1)
                {
                    UpdateClient();
                }
            }
            catch
            {
                _ = netMode;
                _ = 2;
            }
        }
        else
        {
            if (netMode == 2)
            {
                UpdateServer();
            }
            if (netMode == 1)
            {
                UpdateClient();
            }
        }
        chatMonitor.Update();
        upTimer = (float)sw.Elapsed.TotalMilliseconds;
        if (upTimerMaxDelay > 0f)
        {
            upTimerMaxDelay -= 1f;
        }
        else
        {
            upTimerMax = 0f;
        }
        if (upTimer > upTimerMax)
        {
            upTimerMax = upTimer;
            upTimerMaxDelay = 400f;
        }
        Chest.UpdateChestFrames();
        _ambientWindSys.Update();
        TilesRenderer.Update();
        WallsRenderer.Update();
        if (cameraLerp > 0f)
        {
            cameraLerpTimer++;
            if (cameraLerpTimer >= cameraLerpTimeToggle)
            {
                cameraLerp += (float)((cameraLerpTimer - cameraLerpTimeToggle) / 3 + 1) * 0.001f;
            }
            if (cameraLerp > 1f)
            {
                cameraLerp = 1f;
            }
        }
    }
 
    private static void CheckBossIndexes()
    {
        if (!IsNPCActiveAndOneOfTypes(wofNPCIndex, 113))
        {
            wofNPCIndex = -1;
        }
        if (!IsNPCActiveAndOneOfTypes(NPC.golemBoss, 245))
        {
            NPC.golemBoss = -1;
        }
        if (!IsNPCActiveAndOneOfTypes(NPC.deerclopsBoss, 668))
        {
            NPC.deerclopsBoss = -1;
        }
        if (!IsNPCActiveAndOneOfTypes(NPC.plantBoss, 262))
        {
            NPC.plantBoss = -1;
        }
        if (!IsNPCActiveAndOneOfTypes(NPC.crimsonBoss, 266))
        {
            NPC.crimsonBoss = -1;
        }
    }
 
    public static bool IsNPCActiveAndOneOfTypes(int npcIndex, params int[] types)
    {
        if (npcIndex < 0)
        {
            return false;
        }
        NPC nPC = npc[npcIndex];
        if (!nPC.active)
        {
            return false;
        }
        for (int i = 0; i < types.Length; i++)
        {
            if (nPC.type == types[i])
            {
                return true;
            }
        }
        return false;
    }
 
    private static void UpdateOldNPCShop()
    {
        if (npcShop != oldNPCShop)
        {
            oldNPCShop = npcShop;
            shopSellbackHelper.Clear();
        }
    }
 
    private static void DoUpdate_AnimateCursorColors()
    {
        CursorColor();
        mouseTextColor += (byte)mouseTextColorChange;
        if (mouseTextColor >= byte.MaxValue)
        {
            mouseTextColorChange = -1;
        }
        if (mouseTextColor <= 190)
        {
            mouseTextColorChange = 1;
        }
        masterColor += (float)masterColorDir * 0.05f;
        if (masterColor > 1f)
        {
            masterColor = 1f;
            masterColorDir = -1;
        }
        if (masterColor < 0f)
        {
            masterColor = 0f;
            masterColorDir = 1;
        }
    }
 
    private static void DoUpdate_AnimateTileGlows()
    {
        demonTorch += (float)demonTorchDir * 0.01f;
        if (demonTorch > 1f)
        {
            demonTorch = 1f;
            demonTorchDir = -1;
        }
        if (demonTorch < 0f)
        {
            demonTorch = 0f;
            demonTorchDir = 1;
        }
        martianLight += (float)martianLightDir * 0.015f;
        if (martianLight > 1f)
        {
            martianLight = 1f;
            martianLightDir = -1;
        }
        if (martianLight < 0f)
        {
            martianLight = 0f;
            martianLightDir = 1;
        }
    }
 
    private static void DoUpdate_Enter_ToggleChat()
    {
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Enter) && !keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.LeftAlt) && !keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.RightAlt) && hasFocus)
        {
            if (chatRelease && !drawingPlayerChat && !editSign && !editChest && !gameMenu && !keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Escape))
            {
                SoundEngine.PlaySound(10);
                OpenPlayerChat();
                chatText = "";
            }
            chatRelease = false;
        }
        else
        {
            chatRelease = true;
        }
    }
 
    public static void OpenPlayerChat()
    {
        if (CurrentInputTextTakerOverride == null)
        {
            drawingPlayerChat = true;
            clrInput();
        }
    }
 
    public static void ClosePlayerChat()
    {
        drawingPlayerChat = false;
        PlayerInput.WritingText = false;
        player[myPlayer].releaseHook = false;
        player[myPlayer].releaseThrow = false;
    }
 
    private static void DoUpdate_HandleChat()
    {
        if (CurrentInputTextTakerOverride != null)
        {
            drawingPlayerChat = false;
            return;
        }
        if (editSign)
        {
            drawingPlayerChat = false;
        }
        if (PlayerInput.UsingGamepad)
        {
            drawingPlayerChat = false;
        }
        if (!drawingPlayerChat)
        {
            chatMonitor.ResetOffset();
            return;
        }
        int linesOffset = 0;
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Up))
        {
            linesOffset = 1;
        }
        else if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Down))
        {
            linesOffset = -1;
        }
        chatMonitor.Offset(linesOffset);
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Escape))
        {
            drawingPlayerChat = false;
        }
        string text = chatText;
        chatText = GetInputText(chatText);
        int num = 470;
        num = (int)((float)screenWidth * (1f / UIScale)) - 330;
        if (text != chatText)
        {
            for (float x = ChatManager.GetStringSize(FontAssets.MouseText.Value, chatText, Vector2.One).X; x > (float)num; x = ChatManager.GetStringSize(FontAssets.MouseText.Value, chatText, Vector2.One).X)
            {
                int num2 = Math.Max(0, (int)(x - (float)num) / 100);
                chatText = chatText.Substring(0, chatText.Length - 1 - num2);
            }
        }
        if (text != chatText)
        {
            SoundEngine.PlaySound(12);
        }
        if (!inputTextEnter || !chatRelease)
        {
            return;
        }
        if (chatText != "")
        {
            ChatMessage message = ChatManager.Commands.CreateOutgoingMessage(chatText);
            if (netMode == 1)
            {
                ChatHelper.SendChatMessageFromClient(message);
            }
            else if (netMode == 0)
            {
                ChatManager.Commands.ProcessIncomingMessage(message, myPlayer);
            }
        }
        chatText = "";
        ClosePlayerChat();
        chatRelease = false;
        SoundEngine.PlaySound(11);
    }
 
    private void DoUpdate_HandleInput()
    {
        PlayerInput.UpdateInput();
        UpdateViewZoomKeys();
        PlayerInput.SetZoom_Unscaled();
        UILinkPointNavigator.Update();
        PlayerInput.CacheMousePositionForZoom();
        PlayerInput.SetZoom_MouseInWorld();
        oldKeyState = keyState;
        keyState = Keyboard.GetState();
    }
 
    private static void DoUpdate_AltEnter_ToggleFullscreen()
    {
        if ((keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.LeftAlt) || keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.RightAlt)) && keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Enter) && hasFocus)
        {
            if (toggleFullscreen)
            {
                ToggleFullScreen();
                chatRelease = false;
            }
            toggleFullscreen = false;
        }
        else
        {
            toggleFullscreen = true;
        }
    }
 
    private static void DoUpdate_F11_ToggleUI()
    {
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.F11))
        {
            if (releaseUI)
            {
                if (hideUI)
                {
                    hideUI = false;
                }
                else
                {
                    hideUI = true;
                }
                SoundEngine.PlaySound(12);
            }
            releaseUI = false;
        }
        else
        {
            releaseUI = true;
        }
    }
 
    private static void DoUpdate_F7_ToggleGraphicsDiagnostics()
    {
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.F7) && !drawingPlayerChat && !editSign && !editChest)
        {
            if (drawRelease)
            {
                SoundEngine.PlaySound(12);
                if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.LeftAlt) || keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.RightAlt))
                {
                    TimeLogger.Start();
                }
                else if (drawDiag)
                {
                    drawDiag = false;
                }
                else
                {
                    drawDiag = true;
                }
            }
            drawRelease = false;
        }
        else
        {
            drawRelease = true;
        }
    }
 
    private static void DoUpdate_F8_ToggleNetDiagnostics()
    {
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.F8) && !drawingPlayerChat && !editSign && !editChest)
        {
            if (netRelease)
            {
                SoundEngine.PlaySound(12);
                shouldDrawNetDiagnosticsUI = !shouldDrawNetDiagnosticsUI;
            }
            netRelease = false;
        }
        else
        {
            netRelease = true;
        }
    }
 
    private static void DoUpdate_F9_ToggleLighting()
    {
        if (keyState.PressingShift() && keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.F9) && !drawingPlayerChat && !editSign && !editChest)
        {
            if (RGBRelease)
            {
                SoundEngine.PlaySound(12);
                Lighting.NextLightMode();
            }
            RGBRelease = false;
        }
        else
        {
            RGBRelease = true;
        }
    }
 
    private static void DoUpdate_F10_ToggleFPS()
    {
        if (keyState.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.F10) && !drawingPlayerChat && !editSign && !editChest)
        {
            if (frameRelease)
            {
                SoundEngine.PlaySound(12);
                if (showFrameRate)
                {
                    showFrameRate = false;
                }
                else
                {
                    showFrameRate = true;
                }
            }
            frameRelease = false;
        }
        else
        {
            frameRelease = true;
        }
    }
 
    private static void AnimateTiles()
    {
        tileFrameCounter[12]++;
        if (tileFrameCounter[12] > 5)
        {
            tileFrameCounter[12] = 0;
            tileFrame[12]++;
            if (tileFrame[12] >= 10)
            {
                tileFrame[12] = 0;
            }
        }
        tileFrameCounter[665] = tileFrameCounter[12];
        tileFrame[665] = tileFrame[12];
        tileFrameCounter[639]++;
        if (tileFrameCounter[639] > 5)
        {
            tileFrameCounter[639] = 0;
            tileFrame[639]++;
            if (tileFrame[639] >= 10)
            {
                tileFrame[639] = 0;
            }
        }
        tileFrameCounter[17]++;
        if (tileFrameCounter[17] > 5)
        {
            tileFrameCounter[17] = 0;
            tileFrame[17]++;
            if (tileFrame[17] >= 12)
            {
                tileFrame[17] = 0;
            }
        }
        if (++tileFrameCounter[133] >= 4)
        {
            tileFrameCounter[133] = 0;
            if (++tileFrame[133] >= 6)
            {
                tileFrame[133] = 0;
            }
        }
        tileFrameCounter[31]++;
        if (tileFrameCounter[31] > 10)
        {
            tileFrameCounter[31] = 0;
            tileFrame[31]++;
            if (tileFrame[31] > 1)
            {
                tileFrame[31] = 0;
            }
        }
        tileFrameCounter[77]++;
        if (tileFrameCounter[77] > 5)
        {
            tileFrameCounter[77] = 0;
            tileFrame[77]++;
            if (tileFrame[77] >= 12)
            {
                tileFrame[77] = 0;
            }
        }
        tileFrameCounter[106]++;
        if (tileFrameCounter[106] > 4)
        {
            tileFrameCounter[106] = 0;
            tileFrame[106]++;
            if (tileFrame[106] >= 2)
            {
                tileFrame[106] = 0;
            }
        }
        tileFrameCounter[207]++;
        if (tileFrameCounter[207] > 4)
        {
            tileFrameCounter[207] = 0;
            tileFrame[207]++;
            if (tileFrame[207] >= 6)
            {
                tileFrame[207] = 0;
            }
        }
        tileFrameCounter[215]++;
        if (tileFrameCounter[215] >= 4)
        {
            tileFrameCounter[215] = 0;
            tileFrame[215]++;
            if (tileFrame[215] >= 8)
            {
                tileFrame[215] = 0;
            }
        }
        tileFrameCounter[592]++;
        if (tileFrameCounter[592] >= 5)
        {
            tileFrameCounter[592] = 0;
            tileFrame[592]++;
            if (tileFrame[592] >= 8)
            {
                tileFrame[592] = 0;
            }
        }
        tileFrameCounter[217]++;
        if (tileFrameCounter[217] > 4)
        {
            tileFrameCounter[217] = 0;
            tileFrame[217]++;
            if (tileFrame[217] >= 5)
            {
                tileFrame[217] = 0;
            }
        }
        tileFrameCounter[218]++;
        if (tileFrameCounter[218] > 4)
        {
            tileFrameCounter[218] = 0;
            tileFrame[218]++;
            if (tileFrame[218] >= 2)
            {
                tileFrame[218] = 0;
            }
        }
        tileFrameCounter[219]++;
        if (tileFrameCounter[219] > 4)
        {
            tileFrameCounter[219] = 0;
            tileFrame[219]++;
            if (tileFrame[219] >= 10)
            {
                tileFrame[219] = 0;
            }
        }
        tileFrameCounter[642]++;
        if (tileFrameCounter[642] > 4)
        {
            tileFrameCounter[642] = 0;
            tileFrame[642]++;
            if (tileFrame[642] >= 6)
            {
                tileFrame[642] = 0;
            }
        }
        tileFrameCounter[220]++;
        if (tileFrameCounter[220] > 4)
        {
            tileFrameCounter[220] = 0;
            tileFrame[220]++;
            if (tileFrame[220] >= 4)
            {
                tileFrame[220] = 0;
            }
        }
        tileFrameCounter[231]++;
        if (tileFrameCounter[231] > 16)
        {
            tileFrameCounter[231] = 0;
            tileFrame[231]++;
            if (tileFrame[231] >= 7)
            {
                tileFrame[231] = 0;
            }
        }
        tileFrameCounter[235]++;
        if (tileFrameCounter[235] > 20)
        {
            tileFrameCounter[235] = 0;
            tileFrame[235]++;
            if (tileFrame[235] >= 4)
            {
                tileFrame[235] = 0;
            }
        }
        tileFrameCounter[238]++;
        if (tileFrameCounter[238] > 20)
        {
            tileFrameCounter[238] = 0;
            tileFrame[238]++;
            if (tileFrame[238] >= 4)
            {
                tileFrame[238] = 0;
            }
        }
        tileFrameCounter[243]++;
        if (tileFrameCounter[243] > 4)
        {
            tileFrameCounter[243] = 0;
            tileFrame[243]++;
            if (tileFrame[243] >= 6)
            {
                tileFrame[243] = 0;
            }
        }
        tileFrameCounter[244]++;
        if (tileFrameCounter[244] > 4)
        {
            tileFrameCounter[244] = 0;
            tileFrame[244]++;
            if (tileFrame[244] >= 6)
            {
                tileFrame[244] = 0;
            }
        }
        tileFrameCounter[247]++;
        if (tileFrameCounter[247] > 4)
        {
            tileFrameCounter[247] = 0;
            tileFrame[247]++;
            if (tileFrame[247] > 7)
            {
                tileFrame[247] = 0;
            }
        }
        tileFrameCounter[96]++;
        if (tileFrameCounter[96] > 4)
        {
            tileFrameCounter[96] = 0;
            tileFrame[96]++;
            if (tileFrame[96] > 3)
            {
                tileFrame[96] = 0;
            }
        }
        tileFrameCounter[171]++;
        if (tileFrameCounter[171] > 16)
        {
            tileFrameCounter[171] = 0;
            tileFrame[171]++;
            if (tileFrame[171] > 3)
            {
                tileFrame[171] = 0;
            }
        }
        tileFrameCounter[270]++;
        if (tileFrameCounter[270] > 8)
        {
            tileFrameCounter[270] = 0;
            tileFrame[270]++;
            if (tileFrame[270] > 5)
            {
                tileFrame[270] = 0;
            }
        }
        int num = tileFrame[270];
        tileFrame[271] = num;
        tileFrame[581] = num;
        tileFrameCounter[660]++;
        if (tileFrameCounter[660] > 8)
        {
            tileFrameCounter[660] = 0;
            tileFrame[660]++;
            if (tileFrame[660] > 4)
            {
                tileFrame[660] = 0;
            }
        }
        tileFrameCounter[272]++;
        if (tileFrameCounter[272] >= 10)
        {
            tileFrameCounter[272] = 0;
            tileFrame[272]++;
            if (tileFrame[272] > 1)
            {
                tileFrame[272] = 0;
            }
        }
        tileFrameCounter[300]++;
        if (tileFrameCounter[300] >= 5)
        {
            tileFrameCounter[300] = 0;
            tileFrame[300]++;
            if (tileFrame[300] > 6)
            {
                tileFrame[300] = 0;
            }
        }
        tileFrameCounter[301]++;
        if (tileFrameCounter[301] >= 5)
        {
            tileFrameCounter[301] = 0;
            tileFrame[301]++;
            if (tileFrame[301] > 7)
            {
                tileFrame[301] = 0;
            }
        }
        tileFrameCounter[302]++;
        if (tileFrameCounter[302] >= 5)
        {
            tileFrameCounter[302] = 0;
            tileFrame[302]++;
            if (tileFrame[302] > 3)
            {
                tileFrame[302] = 0;
            }
        }
        tileFrameCounter[303]++;
        if (tileFrameCounter[303] >= 5)
        {
            tileFrameCounter[303] = 0;
            tileFrame[303]++;
            if (tileFrame[303] > 4)
            {
                tileFrame[303] = 0;
            }
        }
        tileFrameCounter[305]++;
        if (tileFrameCounter[305] >= 5)
        {
            tileFrameCounter[305] = 0;
            tileFrame[305]++;
            if (tileFrame[305] > 11)
            {
                tileFrame[305] = 0;
            }
        }
        tileFrameCounter[306]++;
        if (tileFrameCounter[306] >= 5)
        {
            tileFrameCounter[306] = 0;
            tileFrame[306]++;
            if (tileFrame[306] > 11)
            {
                tileFrame[306] = 0;
            }
        }
        tileFrameCounter[307]++;
        if (tileFrameCounter[307] >= 5)
        {
            tileFrameCounter[307] = 0;
            tileFrame[307]++;
            if (tileFrame[307] > 1)
            {
                tileFrame[307] = 0;
            }
        }
        tileFrameCounter[308]++;
        if (tileFrameCounter[308] >= 5)
        {
            tileFrameCounter[308] = 0;
            tileFrame[308]++;
            if (tileFrame[308] > 7)
            {
                tileFrame[308] = 0;
            }
        }
        tileFrameCounter[314]++;
        if (tileFrameCounter[314] >= 10)
        {
            tileFrameCounter[314] = 0;
            tileFrame[314]++;
            if (tileFrame[314] > 4)
            {
                tileFrame[314] = 0;
            }
        }
        tileFrameCounter[326]++;
        if (tileFrameCounter[326] >= 5)
        {
            tileFrameCounter[326] = 0;
            tileFrame[326]++;
            if (tileFrame[326] > 7)
            {
                tileFrame[326] = 0;
            }
        }
        tileFrameCounter[327]++;
        if (tileFrameCounter[327] >= 10)
        {
            tileFrameCounter[327] = 0;
            tileFrame[327]++;
            if (tileFrame[327] > 7)
            {
                tileFrame[327] = 0;
            }
        }
        tileFrameCounter[345]++;
        if (tileFrameCounter[345] >= 10)
        {
            tileFrameCounter[345] = 0;
            tileFrame[345]++;
            if (tileFrame[345] > 7)
            {
                tileFrame[345] = 0;
            }
        }
        tileFrameCounter[458]++;
        if (tileFrameCounter[458] >= 10)
        {
            tileFrameCounter[458] = 0;
            tileFrame[458]++;
            if (tileFrame[458] > 7)
            {
                tileFrame[458] = 0;
            }
        }
        tileFrameCounter[459]++;
        if (tileFrameCounter[459] >= 10)
        {
            tileFrameCounter[459] = 0;
            tileFrame[459]++;
            if (tileFrame[459] > 7)
            {
                tileFrame[459] = 0;
            }
        }
        tileFrameCounter[336]++;
        if (tileFrameCounter[336] >= 5)
        {
            tileFrameCounter[336] = 0;
            tileFrame[336]++;
            if (tileFrame[336] > 3)
            {
                tileFrame[336] = 0;
            }
        }
        tileFrameCounter[328]++;
        if (tileFrameCounter[328] >= 5)
        {
            tileFrameCounter[328] = 0;
            tileFrame[328]++;
            if (tileFrame[328] > 7)
            {
                tileFrame[328] = 0;
            }
        }
        tileFrameCounter[329]++;
        if (tileFrameCounter[329] >= 5)
        {
            tileFrameCounter[329] = 0;
            tileFrame[329]++;
            if (tileFrame[329] > 7)
            {
                tileFrame[329] = 0;
            }
        }
        int num2 = 20;
        if (++tileFrameCounter[507] >= num2 * 8)
        {
            tileFrameCounter[507] = 0;
        }
        if (++tileFrameCounter[508] >= num2 * 8)
        {
            tileFrameCounter[508] = 0;
        }
        for (int i = 340; i <= 344; i++)
        {
            tileFrameCounter[i]++;
            if (tileFrameCounter[i] >= 5)
            {
                tileFrameCounter[i] = 0;
                tileFrame[i]++;
                if (tileFrame[i] > 3)
                {
                    tileFrame[i] = 0;
                }
            }
        }
        tileFrameCounter[351]++;
        if (tileFrameCounter[351] >= 5)
        {
            tileFrameCounter[351] = 0;
            tileFrame[351]++;
            if (tileFrame[351] > 2)
            {
                tileFrame[351] = 0;
            }
        }
        tileFrameCounter[354]++;
        if (tileFrameCounter[354] >= 5)
        {
            tileFrameCounter[354] = 0;
            tileFrame[354]++;
            if (tileFrame[354] >= 8)
            {
                tileFrame[354] = 0;
            }
        }
        tileFrame[355] = tileFrame[354];
        tileFrameCounter[377]++;
        if (tileFrameCounter[377] >= 5)
        {
            tileFrameCounter[377] = 0;
            tileFrame[377]++;
            if (tileFrame[377] >= 4)
            {
                tileFrame[377] = 0;
            }
        }
        tileFrameCounter[379]++;
        if (tileFrameCounter[379] >= 10)
        {
            tileFrameCounter[379] = 0;
            tileFrame[379]++;
            if (tileFrame[379] >= 4)
            {
                tileFrame[379] = 0;
            }
        }
        if (++tileFrameCounter[390] >= 8)
        {
            tileFrameCounter[390] = 0;
            if (++tileFrame[390] >= 7)
            {
                tileFrame[390] = 0;
            }
        }
        if (++tileFrameCounter[228] >= 5)
        {
            tileFrameCounter[228] = 0;
            if (++tileFrame[228] >= 3)
            {
                tileFrame[228] = 0;
            }
        }
        if (++tileFrameCounter[405] >= 5)
        {
            tileFrameCounter[405] = 0;
            if (++tileFrame[405] >= 8)
            {
                tileFrame[405] = 0;
            }
        }
        if (++tileFrameCounter[406] >= 8)
        {
            tileFrameCounter[406] = 0;
            if (++tileFrame[406] >= 6)
            {
                tileFrame[406] = 0;
            }
        }
        if (++tileFrameCounter[452] >= 5)
        {
            tileFrameCounter[452] = 0;
            if (++tileFrame[452] >= 15)
            {
                tileFrame[452] = 0;
            }
        }
        if (++tileFrameCounter[455] >= 5)
        {
            tileFrameCounter[455] = 0;
            if (++tileFrame[455] >= 6)
            {
                tileFrame[455] = 0;
            }
        }
        if (++tileFrameCounter[499] >= 5)
        {
            tileFrameCounter[499] = 0;
            if (++tileFrame[499] >= 8)
            {
                tileFrame[499] = 0;
            }
        }
        if (++tileFrameCounter[129] >= 8)
        {
            tileFrameCounter[129] = 0;
            if (++tileFrame[129] >= 6)
            {
                tileFrame[129] = 0;
            }
        }
        tileFrameCounter[453] += ((!WorldGen.gen) ? rand.Next(3) : 0);
        if (++tileFrameCounter[453] >= 60)
        {
            tileFrameCounter[453] = 0;
        }
        if (++tileFrame[412] >= 240)
        {
            tileFrame[412] = 0;
        }
        tileFrameCounter[456] += ((!WorldGen.gen) ? rand.Next(3) : 0);
        if (++tileFrameCounter[456] >= 80)
        {
            tileFrameCounter[456] = 0;
        }
        if (++tileFrame[456] >= 240)
        {
            tileFrame[456] = 0;
        }
        if (++tileFrameCounter[410] >= 8)
        {
            tileFrameCounter[410] = 0;
            if (++tileFrame[410] >= 8)
            {
                tileFrame[410] = 0;
            }
        }
        if (++tileFrameCounter[480] >= 8)
        {
            tileFrameCounter[480] = 0;
            if (++tileFrame[480] >= 8)
            {
                tileFrame[480] = 0;
            }
        }
        if (++tileFrameCounter[509] >= 8)
        {
            tileFrameCounter[509] = 0;
            if (++tileFrame[509] >= 8)
            {
                tileFrame[509] = 0;
            }
        }
        if (++tileFrameCounter[657] >= 8)
        {
            tileFrameCounter[657] = 0;
            if (++tileFrame[657] >= 8)
            {
                tileFrame[657] = 0;
            }
        }
        if (++tileFrameCounter[658] >= 4)
        {
            tileFrameCounter[658] = 0;
            if (++tileFrame[658] >= 10)
            {
                tileFrame[658] = 0;
            }
        }
        if (++tileFrameCounter[421] >= 4)
        {
            tileFrameCounter[421] = 0;
            if (++tileFrame[421] >= 4)
            {
                tileFrame[421] = 0;
            }
        }
        if (++tileFrameCounter[422] >= 4)
        {
            tileFrameCounter[422] = 0;
            if (--tileFrame[422] < 0)
            {
                tileFrame[422] = 3;
            }
        }
        if (++tileFrameCounter[463] >= 10)
        {
            tileFrameCounter[463] = 0;
            if (++tileFrame[463] >= 6)
            {
                tileFrame[463] = 0;
            }
        }
        if (++tileFrameCounter[464] >= 5)
        {
            tileFrameCounter[464] = 0;
            if (++tileFrame[464] >= 23)
            {
                tileFrame[464] = 0;
            }
        }
        if (++tileFrameCounter[485] >= 20)
        {
            tileFrameCounter[485] = 0;
        }
        if (++tileFrameCounter[491] >= 40)
        {
            tileFrameCounter[491] = 0;
        }
        if (++tileFrameCounter[564] >= 5)
        {
            tileFrameCounter[564] = 0;
            tileFrame[564]++;
            if (tileFrame[564] >= 36)
            {
                tileFrame[564] = 0;
            }
        }
        if (++tileFrameCounter[593] >= 5)
        {
            tileFrameCounter[593] = 0;
            tileFrame[593]++;
            if (tileFrame[593] >= 9)
            {
                tileFrame[593] = 5;
            }
        }
        if (++tileFrameCounter[594] >= 5)
        {
            tileFrameCounter[594] = 0;
            tileFrame[594]++;
            if (tileFrame[594] >= 9)
            {
                tileFrame[594] = 5;
            }
        }
        if (++tileFrameCounter[614] >= 5)
        {
            tileFrameCounter[614] = 0;
            tileFrame[614]++;
            if (tileFrame[614] >= 6)
            {
                tileFrame[614] = 0;
            }
        }
        if (++tileFrameCounter[565] >= 4)
        {
            tileFrameCounter[565] = 0;
            tileFrame[565]++;
            if (tileFrame[565] >= 5)
            {
                tileFrame[565] = 0;
            }
        }
        if (++tileFrameCounter[572] >= 6)
        {
            tileFrameCounter[572] = 0;
            if (++tileFrame[572] >= 4)
            {
                tileFrame[572] = 0;
            }
        }
        if (++tileFrameCounter[597] >= 64)
        {
            tileFrameCounter[597] = 0;
        }
        int num3 = (int)MathHelper.Clamp((float)Math.Floor(Math.Abs(WindForVisuals) * 10f) * (float)Math.Sign(WindForVisuals), -5f, 5f);
        tileFrameCounter[489] += num3;
        tileFrameCounter[489] %= 320;
        if (tileFrameCounter[489] < 0)
        {
            tileFrameCounter[489] += 320;
        }
        AnimateTiles_WeatherVane();
        int num4 = (int)MathHelper.Clamp((float)Math.Floor(Math.Abs(WindForVisuals) * 10f) * (float)Math.Sign(WindForVisuals), -5f, 5f);
        tileFrameCounter[493] += num4;
        tileFrameCounter[493] %= 120;
        if (tileFrameCounter[493] < 0)
        {
            tileFrameCounter[493] += 120;
        }
        AnimateTiles_CritterCages();
    }
 
    private static void AnimateTiles_WeatherVane()
    {
        int num = Math.Sign(WindForVisuals);
        int num2 = (int)MathHelper.Clamp((float)Math.Floor(Math.Abs(WindForVisuals) * 10f), -5f, 5f);
        int num3 = 6;
        tileFrameCounter[490] += num2;
        if (tileFrameCounter[490] < num3)
        {
            return;
        }
        tileFrameCounter[490] -= num3 * tileFrameCounter[490];
        if ((tileFrame[490] != 0 || num != -1) && (tileFrame[490] != 6 || num != 1))
        {
            if (++tileFrame[490] >= 12)
            {
                tileFrame[490] = 0;
                weatherVaneBobframe = 0;
            }
        }
        else if (rand.NextFloat() < Math.Abs(WindForVisuals) * 0.5f && ++weatherVaneBobframe == 8)
        {
            weatherVaneBobframe = 0;
        }
    }
 
    private static void DoUpdate_AnimateWalls()
    {
        wallFrameCounter[136]++;
        if (wallFrameCounter[136] >= 5)
        {
            wallFrameCounter[136] = 0;
            wallFrame[136]++;
            if (wallFrame[136] > 7)
            {
                wallFrame[136] = 0;
            }
        }
        wallFrameCounter[137]++;
        if (wallFrameCounter[137] >= 10)
        {
            wallFrameCounter[137] = 0;
            wallFrame[137]++;
            if (wallFrame[137] > 7)
            {
                wallFrame[137] = 0;
            }
        }
        int num = 226;
        wallFrameCounter[num]++;
        if (wallFrameCounter[num] >= 10)
        {
            wallFrameCounter[num] = 0;
            wallFrame[num]++;
            if (wallFrame[num] > 7)
            {
                wallFrame[num] = 0;
            }
        }
        num = 227;
        wallFrameCounter[num]++;
        if (wallFrameCounter[num] >= 5)
        {
            wallFrameCounter[num] = 0;
            wallFrame[num]++;
            if (wallFrame[num] > 7)
            {
                wallFrame[num] = 0;
            }
        }
        num = 225;
        wallFrameCounter[num]++;
        if (wallFrameCounter[num] >= 5)
        {
            wallFrameCounter[num] = 0;
            wallFrame[num]++;
            if (wallFrame[num] > 1)
            {
                wallFrame[num] = 0;
            }
        }
        wallFrameCounter[172]++;
        if (wallFrameCounter[172] >= 10)
        {
            wallFrameCounter[172] = 0;
            wallFrame[172]++;
            if (wallFrame[172] > 7)
            {
                wallFrame[172] = 0;
            }
        }
        wallFrameCounter[168]++;
        if (wallFrameCounter[168] >= 5)
        {
            wallFrameCounter[168] = 0;
            wallFrame[168]++;
            if (wallFrame[168] > 7)
            {
                wallFrame[168] = 0;
            }
        }
        wallFrameCounter[169]++;
        if (wallFrameCounter[169] >= 5)
        {
            wallFrameCounter[169] = 0;
            wallFrame[169]++;
            if (wallFrame[169] > 7)
            {
                wallFrame[169] = 0;
            }
        }
        int num2 = 20;
        if (++wallFrameCounter[242] >= num2 * 8)
        {
            wallFrameCounter[242] = 0;
        }
        if (++wallFrameCounter[243] >= num2 * 8)
        {
            wallFrameCounter[243] = 0;
        }
        wallFrameCounter[144]++;
        int num3 = 5;
        int num4 = 10;
        if (wallFrameCounter[144] < num3)
        {
            wallFrame[144] = 0;
            return;
        }
        if (wallFrameCounter[144] < num3)
        {
            wallFrame[144] = 1;
            return;
        }
        if (wallFrameCounter[144] < num3 * 2)
        {
            wallFrame[144] = 2;
            return;
        }
        if (wallFrameCounter[144] < num3 * 3)
        {
            wallFrame[144] = 3;
            return;
        }
        if (wallFrameCounter[144] < num3 * 4)
        {
            wallFrame[144] = 4;
            return;
        }
        if (wallFrameCounter[144] < num3 * 5)
        {
            wallFrame[144] = 5;
            return;
        }
        if (wallFrameCounter[144] < num3 * 6)
        {
            wallFrame[144] = 6;
            return;
        }
        if (wallFrameCounter[144] < num3 * 7)
        {
            wallFrame[144] = 7;
            return;
        }
        if (wallFrameCounter[144] < num3 * (8 + num4))
        {
            wallFrame[144] = 8;
            return;
        }
        if (wallFrameCounter[144] < num3 * (9 + num4))
        {
            wallFrame[144] = 7;
            return;
        }
        if (wallFrameCounter[144] < num3 * (10 + num4))
        {
            wallFrame[144] = 6;
            return;
        }
        if (wallFrameCounter[144] < num3 * (11 + num4))
        {
            wallFrame[144] = 5;
            return;
        }
        if (wallFrameCounter[144] < num3 * (12 + num4))
        {
            wallFrame[144] = 4;
            return;
        }
        if (wallFrameCounter[144] < num3 * (13 + num4))
        {
            wallFrame[144] = 3;
            return;
        }
        if (wallFrameCounter[144] < num3 * (14 + num4))
        {
            wallFrame[144] = 2;
            return;
        }
        if (wallFrameCounter[144] < num3 * (15 + num4))
        {
            wallFrame[144] = 1;
            return;
        }
        wallFrame[144] = 0;
        if (wallFrameCounter[144] > num3 * (16 + num4 * 2))
        {
            wallFrameCounter[144] = 0;
        }
    }
 
    private void DoUpdate_AnimateWaterfalls()
    {
        wFrCounter += windSpeedCurrent * 2f;
        if (wFrCounter > 4f)
        {
            wFrCounter = 0f;
            wFrame += 1f;
        }
        if (wFrCounter < 0f)
        {
            wFrCounter = 4f;
            wFrame -= 1f;
        }
        if (wFrame > 16f)
        {
            wFrame = 1f;
        }
        if (wFrame < 1f)
        {
            wFrame = 16f;
        }
        waterfallManager.UpdateFrame();
    }
 
    private static void DoUpdate_AnimateVisualPlayerAura()
    {
        if (gFadeDir == 1)
        {
            gFader += 0.1f;
            gFade = (byte)gFader;
            if (gFade > 150)
            {
                gFadeDir = 0;
            }
        }
        else
        {
            gFader -= 0.1f;
            gFade = (byte)gFader;
            if (gFade < 100)
            {
                gFadeDir = 1;
            }
        }
    }
 
    private void DoUpdate_AnimateDiscoRGB()
    {
        int num = 7;
        if (DiscoStyle == 0)
        {
            DiscoG += num;
            if (DiscoG >= 255)
            {
                DiscoG = 255;
                DiscoStyle++;
            }
        }
        if (DiscoStyle == 1)
        {
            DiscoR -= num;
            if (DiscoR <= 0)
            {
                DiscoR = 0;
                DiscoStyle++;
            }
        }
        if (DiscoStyle == 2)
        {
            DiscoB += num;
            if (DiscoB >= 255)
            {
                DiscoB = 255;
                DiscoStyle++;
            }
        }
        if (DiscoStyle == 3)
        {
            DiscoG -= num;
            if (DiscoG <= 0)
            {
                DiscoG = 0;
                DiscoStyle++;
            }
        }
        if (DiscoStyle == 4)
        {
            DiscoR += num;
            if (DiscoR >= 255)
            {
                DiscoR = 255;
                DiscoStyle++;
            }
        }
        if (DiscoStyle == 5)
        {
            DiscoB -= num;
            if (DiscoB <= 0)
            {
                DiscoB = 0;
                DiscoStyle = 0;
            }
        }
    }
 
    private static void DoUpdate_AnimateBackgrounds()
    {
        DoUpdate_AnimateBackgrounds_UpdateForest(0, treeMntBGSet1);
        DoUpdate_AnimateBackgrounds_UpdateForest(10, treeMntBGSet2);
        DoUpdate_AnimateBackgrounds_UpdateForest(11, treeMntBGSet3);
        DoUpdate_AnimateBackgrounds_UpdateForest(12, treeMntBGSet4);
    }
 
    private static void DoUpdate_AnimateBackgrounds_UpdateForest(int bgIndex, int[] bgSet)
    {
        if (bgSet[1] == 94 || (bgSet[1] >= 114 && bgSet[1] <= 116))
        {
            bgFrameCounter[bgIndex]++;
            if (bgFrameCounter[bgIndex] >= 6)
            {
                bgFrameCounter[bgIndex] = 0;
                bgFrame[bgIndex]++;
                if (bgFrame[bgIndex] >= 4)
                {
                    bgFrame[bgIndex] = 0;
                }
            }
            if (bgFrame[bgIndex] == 0)
            {
                bgSet[1] = 94;
            }
            else if (bgFrame[bgIndex] == 1)
            {
                bgSet[1] = 114;
            }
            else if (bgFrame[bgIndex] == 2)
            {
                bgSet[1] = 115;
            }
            else
            {
                bgSet[1] = 116;
            }
            if (bgFrame[bgIndex] == 0)
            {
                bgSet[0] = 93;
            }
            else if (bgFrame[bgIndex] == 1)
            {
                bgSet[0] = 168;
            }
            else if (bgFrame[bgIndex] == 2)
            {
                bgSet[0] = 169;
            }
            else
            {
                bgSet[0] = 170;
            }
        }
        if (bgSet[1] < 180 || bgSet[1] > 183)
        {
            return;
        }
        bgFrameCounter[bgIndex]++;
        if (bgFrameCounter[bgIndex] >= 6)
        {
            bgFrameCounter[bgIndex] = 0;
            bgFrame[bgIndex]++;
            if (bgFrame[bgIndex] >= 4)
            {
                bgFrame[bgIndex] = 0;
            }
        }
        if (bgFrame[bgIndex] == 0)
        {
            bgSet[1] = 180;
        }
        else if (bgFrame[bgIndex] == 1)
        {
            bgSet[1] = 181;
        }
        else if (bgFrame[bgIndex] == 2)
        {
            bgSet[1] = 182;
        }
        else
        {
            bgSet[1] = 183;
        }
    }
 
    private static void DoUpdate_AutoSave()
    {
        if (!gameMenu && netMode == 1)
        {
            if (!saveTime.IsRunning)
            {
                saveTime.Start();
            }
            if (saveTime.ElapsedMilliseconds > 300000)
            {
                saveTime.Reset();
                WorldGen.saveToonWhilePlaying();
            }
        }
        else if (!gameMenu && (autoSave || netMode == 2))
        {
            if (!saveTime.IsRunning)
            {
                saveTime.Start();
            }
            if (saveTime.ElapsedMilliseconds > 600000)
            {
                saveTime.Reset();
                if (netMode != 2)
                {
                    WorldGen.saveToonWhilePlaying();
                }
                WorldGen.saveAndPlay();
            }
        }
        else if (saveTime.IsRunning)
        {
            saveTime.Stop();
        }
    }
 
    private static void UpdateSettingUnlocks()
    {
        if (netMode != 2 && !dedServ && hardMode && !SettingsUnlock_WorldEvil)
        {
            SettingsUnlock_WorldEvil = true;
            SaveSettings();
        }
    }
 
    public static void InputTextSign()
    {
        if (!IngameFancyUI.CanShowVirtualKeyboard(1) || UIVirtualKeyboard.KeyboardContext != 1)
        {
            PlayerInput.WritingText = true;
            instance.HandleIME();
            npcChatText = GetInputText(npcChatText, allowMultiLine: true);
            if (inputTextEnter)
            {
                byte[] bytes = new byte[1] { 10 };
                npcChatText += Encoding.ASCII.GetString(bytes);
            }
            else if (inputTextEscape)
            {
                InputTextSignCancel();
            }
        }
    }
 
    public static void InputTextChest()
    {
        if (!IngameFancyUI.CanShowVirtualKeyboard(2) || UIVirtualKeyboard.KeyboardContext != 2)
        {
            npcChatText = GetInputText(npcChatText);
            if (inputTextEnter)
            {
                ChestUI.RenameChestSubmit(player[myPlayer]);
            }
            else if (inputTextEscape)
            {
                ChestUI.RenameChestCancel();
            }
        }
    }
 
    public static void InputTextSignCancel()
    {
        SoundEngine.PlaySound(12);
        editSign = false;
        blockKey = Microsoft.Xna.Framework.Input.Keys.Escape.ToString();
        UIVirtualKeyboard.CacheCanceledInput(1);
        if (player[myPlayer].sign >= 0)
        {
            npcChatText = sign[player[myPlayer].sign].text;
        }
    }
 
    private static void UpdateMenu()
    {
        if (WorldGen.drunkWorldGen)
        {
            if (WorldGen.remixWorldGen)
            {
                screenPosition.X -= 20f;
            }
            if (WorldGen.drunkWorldGenText)
            {
                numClouds = rand.Next(100, 200);
                statusText = string.Concat(rand.Next(999999999));
                for (int i = 0; i < 3; i++)
                {
                    if (rand.Next(2) == 0)
                    {
                        statusText += rand.Next(999999999);
                    }
                }
            }
        }
        gamePaused = false;
        thunderDelay = 0;
        lightning = 0f;
        lightningSpeed = 0f;
        GraveyardVisualIntensity = 0f;
        InGameNotificationsTracker.Clear();
        playerInventory = false;
        exitScale = 0.8f;
        if (netMode == 0)
        {
            if (instance.IsActive && hasFocus && (!dayTime || WorldGen.remixWorldGen) && (rand.Next(12) == 0 || (WorldGen.drunkWorldGen && !remixWorld)))
            {
                int num = rand.Next(numStars);
                if (star[num] != null && !star[num].hidden && !star[num].falling)
                {
                    star[num].Fall();
                }
            }
            if (gameMenu)
            {
                if (WorldGen.gen)
                {
                    lockMenuBGChange = true;
                }
                else if (menuMode == 0)
                {
                    lockMenuBGChange = false;
                }
                if (!lockMenuBGChange)
                {
                    if (dayTime)
                    {
                        menuBGChangedDay = false;
                    }
                    else if (!menuBGChangedDay && time >= 16200.0)
                    {
                        menuBGChangedDay = true;
                        int style = WorldGen.corruptBG;
                        WorldGen.RandomizeBackgrounds(rand);
                        if (treeBGSet1[0] == 173)
                        {
                            WorldGen.RandomizeBackgrounds(rand);
                        }
                        if (treeBGSet1[0] == 173)
                        {
                            WorldGen.RandomizeBackgrounds(rand);
                        }
                        WorldGen.setBG(1, style);
                    }
                    if (!dayTime)
                    {
                        menuBGChangedNight = false;
                    }
                    else if (!menuBGChangedNight && time >= 27000.0)
                    {
                        moonType = rand.Next(9);
                        menuBGChangedNight = true;
                        int treeBG = WorldGen.treeBG1;
                        WorldGen.RandomizeBackgrounds(rand);
                        WorldGen.setBG(0, treeBG);
                    }
                }
                else
                {
                    menuBGChangedDay = true;
                    menuBGChangedNight = true;
                }
            }
            if (alreadyGrabbingSunOrMoon)
            {
                return;
            }
            if (WorldGen.drunkWorldGen && !WorldGen.remixWorldGen)
            {
                time -= 6.0;
                if (dayTime)
                {
                    time -= 1000.0;
                }
                if (time < 0.0)
                {
                    time = 32400.0;
                    dayTime = false;
                }
            }
            else if (dayTime)
            {
                time += 33.88235294117647;
            }
            else
            {
                time += 30.857142857142858;
            }
            if (!dayTime)
            {
                if (time > 32400.0)
                {
                    bloodMoon = false;
                    time = 0.0;
                    dayTime = true;
                    if (starGame)
                    {
                        dayTime = false;
                    }
                    moonPhase++;
                    if (moonPhase >= 7)
                    {
                        moonPhase = 0;
                    }
                }
            }
            else if (time > 54000.0)
            {
                time = 0.0;
                dayTime = false;
            }
        }
        else if (netMode == 1)
        {
            UpdateTime();
        }
    }
 
    public static void clrInput()
    {
        keyCount = 0;
        inputTextEscape = false;
    }
 
    [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
    public static extern short GetKeyState(int keyCode);
 
    public static string GetInputText(string oldString, bool allowMultiLine = false)
    {
        if (dedServ)
        {
            return "";
        }
        if (!hasFocus)
        {
            return oldString;
        }
        inputTextEnter = false;
        inputTextEscape = false;
        string text = oldString;
        string text2 = "";
        if (text == null)
        {
            text = "";
        }
        bool flag = false;
        if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.LeftControl) || inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.RightControl))
        {
            if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Z) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Z))
            {
                text = "";
            }
            else if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.X) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.X))
            {
                Platform.Get<IClipboard>().Value = oldString;
                text = "";
            }
            else if ((inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.C) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.C)) || (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Insert) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Insert)))
            {
                Platform.Get<IClipboard>().Value = oldString;
            }
            else if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.V) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.V))
            {
                text2 = PasteTextIn(allowMultiLine, text2);
            }
        }
        else
        {
            if (inputText.PressingShift())
            {
                if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Delete) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Delete))
                {
                    Platform.Get<IClipboard>().Value = oldString;
                    text = "";
                }
                if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Insert) && !oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Insert))
                {
                    text2 = PasteTextIn(allowMultiLine, text2);
                }
            }
            for (int i = 0; i < keyCount; i++)
            {
                int num = keyInt[i];
                string text3 = keyString[i];
                if (num == 13)
                {
                    inputTextEnter = true;
                }
                else if (num == 27)
                {
                    inputTextEscape = true;
                }
                else if (num >= 32 && num != 127)
                {
                    text2 += text3;
                }
            }
        }
        keyCount = 0;
        text += text2;
        oldInputText = inputText;
        inputText = Keyboard.GetState();
        Microsoft.Xna.Framework.Input.Keys[] pressedKeys = inputText.GetPressedKeys();
        Microsoft.Xna.Framework.Input.Keys[] pressedKeys2 = oldInputText.GetPressedKeys();
        if (inputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Back) && oldInputText.IsKeyDown(Microsoft.Xna.Framework.Input.Keys.Back))
        {
            backSpaceRate -= 0.05f;
            if (backSpaceRate < 0f)
            {
                backSpaceRate = 0f;
            }
            if (backSpaceCount <= 0)
            {
                backSpaceCount = (int)Math.Round(backSpaceRate);
                flag = true;
            }
            backSpaceCount--;
        }
        else
        {
            backSpaceRate = 7f;
            backSpaceCount = 15;
        }
        for (int j = 0; j < pressedKeys.Length; j++)
        {
            bool flag2 = true;
            for (int k = 0; k < pressedKeys2.Length; k++)
            {
                if (pressedKeys[j] == pressedKeys2[k])
                {
                    flag2 = false;
                }
            }
            if (string.Concat(pressedKeys[j]) == "Back" && (flag2 || flag) && text.Length > 0)
            {
                TextSnippet[] array = ChatManager.ParseMessage(text, Microsoft.Xna.Framework.Color.White).ToArray();
                text = ((!array[array.Length - 1].DeleteWhole) ? text.Substring(0, text.Length - 1) : text.Substring(0, text.Length - array[array.Length - 1].TextOriginal.Length));
            }
        }
        return text;
    }
 
    private static string PasteTextIn(bool allowMultiLine, string newKeys)
    {
        newKeys = ((!allowMultiLine) ? (newKeys + Platform.Get<IClipboard>().Value) : (newKeys + Platform.Get<IClipboard>().MultiLineValue));
        return newKeys;
    }
 
    public void MouseTextHackZoom(string text, string buffTooltip = null)
    {
        MouseTextHackZoom(text, 0, 0, buffTooltip);
    }
 
    public void MouseTextHackZoom(string text, int itemRarity, byte diff = 0, string buffTooltip = null)
    {
        MouseText(text, buffTooltip, itemRarity, diff);
    }
 
    public void MouseTextNoOverride(string cursorText, int rare = 0, byte diff = 0, int hackedMouseX = -1, int hackedMouseY = -1, int hackedScreenWidth = -1, int hackedScreenHeight = -1, int pushWidthX = 0)
    {
        MouseText(cursorText, null, rare, diff, hackedMouseX, hackedMouseY, hackedScreenWidth, hackedScreenHeight, pushWidthX, noOverride: true);
    }
 
    public void MouseText(string cursorText, int rare = 0, byte diff = 0, int hackedMouseX = -1, int hackedMouseY = -1, int hackedScreenWidth = -1, int hackedScreenHeight = -1, int pushWidthX = 0)
    {
        MouseText(cursorText, null, rare, diff, hackedMouseX, hackedMouseY, hackedScreenWidth, hackedScreenHeight, pushWidthX);
    }
 
    public void MouseText(string cursorText, string buffTooltip, int rare = 0, byte diff = 0, int hackedMouseX = -1, int hackedMouseY = -1, int hackedScreenWidth = -1, int hackedScreenHeight = -1, int pushWidthX = 0, bool noOverride = false)
    {
        if (!_mouseTextCache.noOverride)
        {
            _mouseTextCache = new MouseTextCache
            {
                noOverride = noOverride,
                isValid = true,
                cursorText = cursorText,
                rare = rare,
                diff = diff,
                X = hackedMouseX,
                Y = hackedMouseY,
                hackedScreenWidth = hackedScreenWidth,
                hackedScreenHeight = hackedScreenHeight,
                buffTooltip = buffTooltip
            };
        }
    }
 
    private void MouseTextInner(MouseTextCache info)
    {
        string cursorText = info.cursorText;
        int num = info.rare;
        byte diff = info.diff;
        int x = info.X;
        int y = info.Y;
        int hackedScreenWidth = info.hackedScreenWidth;
        int hackedScreenHeight = info.hackedScreenHeight;
        if (mouseNPCType > -1 || cursorText == null)
        {
            return;
        }
        int X = mouseX + 14;
        int Y = mouseY + 14;
        if (x != -1 && y != -1)
        {
            X = x + 10;
            Y = y + 10;
        }
        if (ThickMouse)
        {
            X += 6;
            Y += 6;
        }
        if (!mouseItem.IsAir)
        {
            X += 34;
        }
        new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
        if (HoverItem.type > 0)
        {
            MouseText_DrawItemTooltip(info, num, diff, X, Y);
            return;
        }
        if (info.buffTooltip != null && info.buffTooltip != "")
        {
            MouseText_DrawBuffTooltip(info.buffTooltip, ref X, ref Y);
        }
        Vector2 vector = FontAssets.MouseText.Value.MeasureString(cursorText);
        if (hackedScreenHeight != -1 && hackedScreenWidth != -1)
        {
            if ((float)X + vector.X + 4f > (float)hackedScreenWidth)
            {
                X = (int)((float)hackedScreenWidth - vector.X - 4f);
            }
            if ((float)Y + vector.Y + 4f > (float)hackedScreenHeight)
            {
                Y = (int)((float)hackedScreenHeight - vector.Y - 4f);
            }
        }
        else
        {
            if ((float)X + vector.X + 4f > (float)screenWidth)
            {
                X = (int)((float)screenWidth - vector.X - 4f);
            }
            if ((float)Y + vector.Y + 4f > (float)screenHeight)
            {
                Y = (int)((float)screenHeight - vector.Y - 4f);
            }
        }
        float num2 = (float)(int)mouseTextColor / 255f;
        Microsoft.Xna.Framework.Color baseColor = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
        if (num == -13)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(masterColor * 200f * num2), 0, mouseTextColor);
        }
        if (num == -11)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(175f * num2), (byte)(0f * num2), mouseTextColor);
        }
        if (num == -10)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(65f * num2), (byte)(255f * num2), (byte)(110f * num2), mouseTextColor);
        }
        if (num == -1)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(130f * num2), (byte)(130f * num2), (byte)(130f * num2), mouseTextColor);
        }
        if (num == 1)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(150f * num2), (byte)(150f * num2), (byte)(255f * num2), mouseTextColor);
        }
        if (num == 2)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(150f * num2), (byte)(255f * num2), (byte)(150f * num2), mouseTextColor);
        }
        if (num == 3)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(200f * num2), (byte)(150f * num2), mouseTextColor);
        }
        if (num == 4)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(150f * num2), (byte)(150f * num2), mouseTextColor);
        }
        if (num == 5)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(150f * num2), (byte)(255f * num2), mouseTextColor);
        }
        if (num == 6)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(210f * num2), (byte)(160f * num2), (byte)(255f * num2), mouseTextColor);
        }
        if (num == 7)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(150f * num2), (byte)(255f * num2), (byte)(10f * num2), mouseTextColor);
        }
        if (num == 8)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(255f * num2), (byte)(10f * num2), mouseTextColor);
        }
        if (num == 9)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(5f * num2), (byte)(200f * num2), (byte)(255f * num2), mouseTextColor);
        }
        if (num == 10)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(255f * num2), (byte)(40f * num2), (byte)(100f * num2), mouseTextColor);
        }
        if (num >= 11)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)(180f * num2), (byte)(40f * num2), (byte)(255f * num2), mouseTextColor);
        }
        if (HoverItem.expert || num == -12)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)((float)DiscoR * num2), (byte)((float)DiscoG * num2), (byte)((float)DiscoB * num2), mouseTextColor);
        }
        if (diff == 1)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)((float)(int)mcColor.R * num2), (byte)((float)(int)mcColor.G * num2), (byte)((float)(int)mcColor.B * num2), mouseTextColor);
        }
        if (diff == 2)
        {
            baseColor = new Microsoft.Xna.Framework.Color((byte)((float)(int)hcColor.R * num2), (byte)((float)(int)hcColor.G * num2), (byte)((float)(int)hcColor.B * num2), mouseTextColor);
        }
        ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, cursorText, new Vector2(X, Y), baseColor, 0f, Vector2.Zero, Vector2.One);
    }
 
    private void MouseText_DrawItemTooltip(MouseTextCache info, int rare, byte diff, int X, int Y)
    {
        bool settingsEnabled_OpaqueBoxBehindTooltips = SettingsEnabled_OpaqueBoxBehindTooltips;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
        Item hoverItem = HoverItem;
        int yoyoLogo = -1;
        int researchLine = -1;
        rare = hoverItem.rare;
        float knockBack = hoverItem.knockBack;
        float num = 1f;
        if (hoverItem.melee && player[myPlayer].kbGlove)
        {
            num += 1f;
        }
        if (player[myPlayer].kbBuff)
        {
            num += 0.5f;
        }
        if (num != 1f)
        {
            hoverItem.knockBack *= num;
        }
        if (hoverItem.ranged && player[myPlayer].shroomiteStealth)
        {
            hoverItem.knockBack *= 1f + (1f - player[myPlayer].stealth) * 0.5f;
        }
        int num2 = 30;
        int numLines = 1;
        string[] array = new string[num2];
        bool[] array2 = new bool[num2];
        bool[] array3 = new bool[num2];
        for (int i = 0; i < num2; i++)
        {
            array2[i] = false;
            array3[i] = false;
        }
        MouseText_DrawItemTooltip_GetLinesInfo(hoverItem, ref yoyoLogo, ref researchLine, knockBack, ref numLines, array, array2, array3);
        float num3 = (float)(int)mouseTextColor / 255f;
        float num4 = num3;
        int a = mouseTextColor;
        if (npcShop > 0 && hoverItem.value >= 0 && (hoverItem.type < 71 || hoverItem.type > 74))
        {
            LocalPlayer.GetItemExpectedPrice(hoverItem, out var calcForSelling, out var calcForBuying);
            long num5 = ((hoverItem.isAShopItem || hoverItem.buyOnce) ? calcForBuying : calcForSelling);
            if (hoverItem.shopSpecialCurrency != -1)
            {
                CustomCurrencyManager.GetPriceText(hoverItem.shopSpecialCurrency, array, ref numLines, num5);
                color = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(255f * num4), (byte)(255f * num4), a);
            }
            else if (num5 > 0)
            {
                string text = "";
                long num6 = 0L;
                long num7 = 0L;
                long num8 = 0L;
                long num9 = 0L;
                long num10 = num5 * hoverItem.stack;
                if (!hoverItem.buy)
                {
                    num10 = num5 / 5;
                    if (num10 < 1)
                    {
                        num10 = 1L;
                    }
                    long num11 = num10;
                    num10 *= hoverItem.stack;
                    int amount = shopSellbackHelper.GetAmount(hoverItem);
                    if (amount > 0)
                    {
                        num10 += (-num11 + calcForBuying) * Math.Min(amount, hoverItem.stack);
                    }
                }
                if (num10 < 1)
                {
                    num10 = 1L;
                }
                if (num10 >= 1000000)
                {
                    num6 = num10 / 1000000;
                    num10 -= num6 * 1000000;
                }
                if (num10 >= 10000)
                {
                    num7 = num10 / 10000;
                    num10 -= num7 * 10000;
                }
                if (num10 >= 100)
                {
                    num8 = num10 / 100;
                    num10 -= num8 * 100;
                }
                if (num10 >= 1)
                {
                    num9 = num10;
                }
                if (num6 > 0)
                {
                    text = text + num6 + " " + Lang.inter[15].Value + " ";
                }
                if (num7 > 0)
                {
                    text = text + num7 + " " + Lang.inter[16].Value + " ";
                }
                if (num8 > 0)
                {
                    text = text + num8 + " " + Lang.inter[17].Value + " ";
                }
                if (num9 > 0)
                {
                    text = text + num9 + " " + Lang.inter[18].Value + " ";
                }
                if (!hoverItem.buy)
                {
                    array[numLines] = Lang.tip[49].Value + " " + text;
                }
                else
                {
                    array[numLines] = Lang.tip[50].Value + " " + text;
                }
                numLines++;
                if (num6 > 0)
                {
                    color = new Microsoft.Xna.Framework.Color((byte)(220f * num4), (byte)(220f * num4), (byte)(198f * num4), a);
                }
                else if (num7 > 0)
                {
                    color = new Microsoft.Xna.Framework.Color((byte)(224f * num4), (byte)(201f * num4), (byte)(92f * num4), a);
                }
                else if (num8 > 0)
                {
                    color = new Microsoft.Xna.Framework.Color((byte)(181f * num4), (byte)(192f * num4), (byte)(193f * num4), a);
                }
                else if (num9 > 0)
                {
                    color = new Microsoft.Xna.Framework.Color((byte)(246f * num4), (byte)(138f * num4), (byte)(96f * num4), a);
                }
            }
            else if (hoverItem.type != 3817)
            {
                array[numLines] = Lang.tip[51].Value;
                numLines++;
                color = new Microsoft.Xna.Framework.Color((byte)(120f * num4), (byte)(120f * num4), (byte)(120f * num4), a);
            }
        }
        Vector2 zero = Vector2.Zero;
        int num12 = 0;
        for (int j = 0; j < numLines; j++)
        {
            Vector2 stringSize = ChatManager.GetStringSize(FontAssets.MouseText.Value, array[j], Vector2.One);
            if (stringSize.X > zero.X)
            {
                zero.X = stringSize.X;
            }
            zero.Y += stringSize.Y + (float)num12;
        }
        if (yoyoLogo != -1)
        {
            zero.Y += 24f;
        }
        X += toolTipDistance;
        Y += toolTipDistance;
        int num13 = 4;
        if (settingsEnabled_OpaqueBoxBehindTooltips)
        {
            X += 8;
            Y += 2;
            num13 = 18;
        }
        int num14 = screenWidth;
        int num15 = screenHeight;
        if ((float)X + zero.X + (float)num13 > (float)num14)
        {
            X = (int)((float)num14 - zero.X - (float)num13);
        }
        if ((float)Y + zero.Y + (float)num13 > (float)num15)
        {
            Y = (int)((float)num15 - zero.Y - (float)num13);
        }
        int num16 = 0;
        num3 = (float)(int)mouseTextColor / 255f;
        if (settingsEnabled_OpaqueBoxBehindTooltips)
        {
            num3 = MathHelper.Lerp(num3, 1f, 1f);
            int num17 = 14;
            int num18 = 9;
            Utils.DrawInvBG(spriteBatch, new Microsoft.Xna.Framework.Rectangle(X - num17, Y - num18, (int)zero.X + num17 * 2, (int)zero.Y + num18 + num18 / 2), new Microsoft.Xna.Framework.Color(23, 25, 81, 255) * 0.925f);
        }
        for (int k = 0; k < numLines; k++)
        {
            if (k == yoyoLogo)
            {
                float num19 = 1f;
                int num20 = (int)((float)(int)mouseTextColor * num19);
                Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Black;
                for (int l = 0; l < 5; l++)
                {
                    int num21 = X;
                    int num22 = Y + num16;
                    if (l == 4)
                    {
                        color2 = new Microsoft.Xna.Framework.Color(num20, num20, num20, num20);
                    }
                    switch (l)
                    {
                    case 0:
                        num21--;
                        break;
                    case 1:
                        num21++;
                        break;
                    case 2:
                        num22--;
                        break;
                    case 3:
                        num22++;
                        break;
                    }
                    spriteBatch.Draw(TextureAssets.OneDropLogo.Value, new Vector2(num21, num22), null, color2, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                }
            }
            else
            {
                Microsoft.Xna.Framework.Color black = Microsoft.Xna.Framework.Color.Black;
                black = new Microsoft.Xna.Framework.Color(num4, num4, num4, num4);
                if (k == 0)
                {
                    if (rare == -13)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(masterColor * 200f * num4), 0, a);
                    }
                    if (rare == -11)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(175f * num4), (byte)(0f * num4), a);
                    }
                    if (rare == -1)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(130f * num4), (byte)(130f * num4), (byte)(130f * num4), a);
                    }
                    if (rare == 1)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(150f * num4), (byte)(150f * num4), (byte)(255f * num4), a);
                    }
                    if (rare == 2)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(150f * num4), (byte)(255f * num4), (byte)(150f * num4), a);
                    }
                    if (rare == 3)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(200f * num4), (byte)(150f * num4), a);
                    }
                    if (rare == 4)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(150f * num4), (byte)(150f * num4), a);
                    }
                    if (rare == 5)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(150f * num4), (byte)(255f * num4), a);
                    }
                    if (rare == 6)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(210f * num4), (byte)(160f * num4), (byte)(255f * num4), a);
                    }
                    if (rare == 7)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(150f * num4), (byte)(255f * num4), (byte)(10f * num4), a);
                    }
                    if (rare == 8)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(255f * num4), (byte)(10f * num4), a);
                    }
                    if (rare == 9)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(5f * num4), (byte)(200f * num4), (byte)(255f * num4), a);
                    }
                    if (rare == 10)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(255f * num4), (byte)(40f * num4), (byte)(100f * num4), a);
                    }
                    if (rare >= 11)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)(180f * num4), (byte)(40f * num4), (byte)(255f * num4), a);
                    }
                    if (diff == 1)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)((float)(int)mcColor.R * num4), (byte)((float)(int)mcColor.G * num4), (byte)((float)(int)mcColor.B * num4), a);
                    }
                    if (diff == 2)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)((float)(int)hcColor.R * num4), (byte)((float)(int)hcColor.G * num4), (byte)((float)(int)hcColor.B * num4), a);
                    }
                    if (hoverItem.expert || rare == -12)
                    {
                        black = new Microsoft.Xna.Framework.Color((byte)((float)DiscoR * num4), (byte)((float)DiscoG * num4), (byte)((float)DiscoB * num4), a);
                    }
                }
                else if (array2[k])
                {
                    black = ((!array3[k]) ? new Microsoft.Xna.Framework.Color((byte)(120f * num4), (byte)(190f * num4), (byte)(120f * num4), a) : new Microsoft.Xna.Framework.Color((byte)(190f * num4), (byte)(120f * num4), (byte)(120f * num4), a));
                }
                else if (k == numLines - 1)
                {
                    black = color;
                }
                if (k == researchLine)
                {
                    black = Colors.JourneyMode;
                }
                ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, array[k], new Vector2(X, Y + num16), black, 0f, Vector2.Zero, Vector2.One);
            }
            num16 += (int)(FontAssets.MouseText.Value.MeasureString(array[k]).Y + (float)num12);
        }
    }
 
    public static void MouseText_DrawItemTooltip_GetLinesInfo(Item item, ref int yoyoLogo, ref int researchLine, float oldKB, ref int numLines, string[] toolTipLine, bool[] preFixLine, bool[] badPreFixLine)
    {
        toolTipLine[0] = item.HoverName;
        if (item.favorited)
        {
            toolTipLine[numLines++] = Lang.tip[56].Value;
            toolTipLine[numLines++] = Lang.tip[57].Value;
            if (LocalPlayer.chest != -1)
            {
                ChestUI.GetContainerUsageInfo(out var _, out var chestinv);
                if (ChestUI.IsBlockedFromTransferIntoChest(item, chestinv))
                {
                    toolTipLine[numLines++] = Language.GetTextValue("UI.ItemCannotBePlacedInsideItself");
                }
            }
        }
        if (item.social)
        {
            toolTipLine[numLines] = Lang.tip[0].Value;
            numLines++;
            toolTipLine[numLines] = Lang.tip[1].Value;
            numLines++;
        }
        else
        {
            if (item.damage > 0 && (!item.notAmmo || item.useStyle != 0) && (item.type < 71 || item.type > 74 || player[myPlayer].HasItem(905)))
            {
                float num = 5E-06f;
                int damage = item.damage;
                damage = (int)((float)damage * ItemID.Sets.ToolTipDamageMultiplier[item.type]);
                if (item.melee)
                {
                    toolTipLine[numLines] = string.Concat((int)(LocalPlayer.meleeDamage * (float)damage + num));
                    toolTipLine[numLines] += Lang.tip[2].Value;
                }
                else if (item.ranged)
                {
                    float num2 = LocalPlayer.rangedDamage;
                    if (item.useAmmo == AmmoID.Arrow || item.useAmmo == AmmoID.Stake)
                    {
                        num2 = LocalPlayer.bowEffectiveDamage;
                        if (LocalPlayer.archery)
                        {
                            num2 *= 1.1f;
                        }
                    }
                    if (item.useAmmo == AmmoID.Bullet || item.useAmmo == AmmoID.CandyCorn)
                    {
                        num2 = LocalPlayer.gunEffectiveDamage;
                    }
                    if (item.useAmmo == AmmoID.Rocket || item.useAmmo == AmmoID.StyngerBolt || item.useAmmo == AmmoID.JackOLantern || item.useAmmo == AmmoID.NailFriendly || item.useAmmo == AmmoID.Coin || item.useAmmo == AmmoID.Flare || item.useAmmo == AmmoID.Dart || item.useAmmo == AmmoID.Snowball || item.useAmmo == AmmoID.Sand || item.useAmmo == AmmoID.FallenStar || item.useAmmo == AmmoID.Gel)
                    {
                        num2 = LocalPlayer.specialistEffectiveDamage;
                    }
                    if (item.type == 1156 || item.type == 3350 || item.type == 3210 || item.type == 160 || item.type == 3821)
                    {
                        num2 = LocalPlayer.specialistEffectiveDamage;
                    }
                    toolTipLine[numLines] = string.Concat((int)(num2 * (float)damage + num));
                    toolTipLine[numLines] += Lang.tip[3].Value;
                }
                else if (item.magic)
                {
                    toolTipLine[numLines] = string.Concat((int)(LocalPlayer.magicDamage * (float)damage + num));
                    toolTipLine[numLines] += Lang.tip[4].Value;
                }
                else if (item.summon)
                {
                    toolTipLine[numLines] = string.Concat((int)(LocalPlayer.minionDamage * (float)damage + num));
                    toolTipLine[numLines] += Lang.tip[53].Value;
                }
                else
                {
                    toolTipLine[numLines] = string.Concat(damage);
                    toolTipLine[numLines] += Lang.tip[55].Value;
                }
                numLines++;
                if (item.melee)
                {
                    int num3 = player[myPlayer].meleeCrit - player[myPlayer].inventory[player[myPlayer].selectedItem].crit + item.crit;
                    toolTipLine[numLines] = num3 + Lang.tip[5].Value;
                    numLines++;
                }
                else if (item.ranged)
                {
                    int num4 = player[myPlayer].rangedCrit - player[myPlayer].inventory[player[myPlayer].selectedItem].crit + item.crit;
                    toolTipLine[numLines] = num4 + Lang.tip[5].Value;
                    numLines++;
                }
                else if (item.magic)
                {
                    int num5 = player[myPlayer].magicCrit - player[myPlayer].inventory[player[myPlayer].selectedItem].crit + item.crit;
                    toolTipLine[numLines] = num5 + Lang.tip[5].Value;
                    numLines++;
                }
                if (item.useStyle != 0 && !item.summon)
                {
                    if (item.useAnimation <= 8)
                    {
                        toolTipLine[numLines] = Lang.tip[6].Value;
                    }
                    else if (item.useAnimation <= 20)
                    {
                        toolTipLine[numLines] = Lang.tip[7].Value;
                    }
                    else if (item.useAnimation <= 25)
                    {
                        toolTipLine[numLines] = Lang.tip[8].Value;
                    }
                    else if (item.useAnimation <= 30)
                    {
                        toolTipLine[numLines] = Lang.tip[9].Value;
                    }
                    else if (item.useAnimation <= 35)
                    {
                        toolTipLine[numLines] = Lang.tip[10].Value;
                    }
                    else if (item.useAnimation <= 45)
                    {
                        toolTipLine[numLines] = Lang.tip[11].Value;
                    }
                    else if (item.useAnimation <= 55)
                    {
                        toolTipLine[numLines] = Lang.tip[12].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = Lang.tip[13].Value;
                    }
                    numLines++;
                }
                float num6 = item.knockBack;
                if (item.summon)
                {
                    num6 += player[myPlayer].minionKB;
                }
                if ((player[myPlayer].magicQuiver && item.useAmmo == AmmoID.Arrow) || item.useAmmo == AmmoID.Stake)
                {
                    num6 = (int)(num6 * 1.1f);
                }
                if (player[myPlayer].inventory[player[myPlayer].selectedItem].type == 3106 && item.type == 3106)
                {
                    num6 += num6 * (1f - player[myPlayer].stealth);
                }
                if (num6 == 0f)
                {
                    toolTipLine[numLines] = Lang.tip[14].Value;
                }
                else if ((double)num6 <= 1.5)
                {
                    toolTipLine[numLines] = Lang.tip[15].Value;
                }
                else if (num6 <= 3f)
                {
                    toolTipLine[numLines] = Lang.tip[16].Value;
                }
                else if (num6 <= 4f)
                {
                    toolTipLine[numLines] = Lang.tip[17].Value;
                }
                else if (num6 <= 6f)
                {
                    toolTipLine[numLines] = Lang.tip[18].Value;
                }
                else if (num6 <= 7f)
                {
                    toolTipLine[numLines] = Lang.tip[19].Value;
                }
                else if (num6 <= 9f)
                {
                    toolTipLine[numLines] = Lang.tip[20].Value;
                }
                else if (num6 <= 11f)
                {
                    toolTipLine[numLines] = Lang.tip[21].Value;
                }
                else
                {
                    toolTipLine[numLines] = Lang.tip[22].Value;
                }
                numLines++;
            }
            if (item.fishingPole > 0)
            {
                toolTipLine[numLines] = Language.GetTextValue("GameUI.PrecentFishingPower", item.fishingPole);
                numLines++;
                toolTipLine[numLines] = Language.GetTextValue("GameUI.BaitRequired");
                numLines++;
            }
            if (item.bait > 0)
            {
                toolTipLine[numLines] = Language.GetTextValue("GameUI.BaitPower", item.bait);
                numLines++;
            }
            if (item.headSlot > 0 || item.bodySlot > 0 || item.legSlot > 0 || item.accessory || projHook[item.shoot] || item.mountType != -1 || (item.buffType > 0 && (lightPet[item.buffType] || vanityPet[item.buffType])))
            {
                if ((item.type == 854 || item.type == 3035) && npcShop > 0)
                {
                    toolTipLine[numLines] = Lang.tip[60].Value;
                }
                else
                {
                    toolTipLine[numLines] = Lang.tip[23].Value;
                }
                numLines++;
            }
            if (item.tileWand > 0)
            {
                toolTipLine[numLines] = Lang.tip[52].Value + Lang.GetItemNameValue(item.tileWand);
                numLines++;
            }
            if (item.questItem)
            {
                toolTipLine[numLines] = Lang.inter[65].Value;
                numLines++;
            }
            if (item.vanity)
            {
                toolTipLine[numLines] = Lang.tip[24].Value;
                numLines++;
            }
            if (item.defense > 0)
            {
                toolTipLine[numLines] = item.defense + Lang.tip[25].Value;
                numLines++;
            }
            if (item.pick > 0)
            {
                toolTipLine[numLines] = item.pick + Lang.tip[26].Value;
                numLines++;
            }
            if (item.axe > 0)
            {
                toolTipLine[numLines] = item.axe * 5 + Lang.tip[27].Value;
                numLines++;
            }
            if (item.hammer > 0)
            {
                toolTipLine[numLines] = item.hammer + Lang.tip[28].Value;
                numLines++;
            }
            if (item.tileBoost != 0)
            {
                int tileBoost = item.tileBoost;
                if (tileBoost > 0)
                {
                    toolTipLine[numLines] = "+" + tileBoost + Lang.tip[54].Value;
                }
                else
                {
                    toolTipLine[numLines] = tileBoost + Lang.tip[54].Value;
                }
                numLines++;
            }
            if (item.healLife > 0)
            {
                if (item.type == 3001)
                {
                    int healLife = item.healLife;
                    int num7 = 120;
                    toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.RestoresLifeRange", healLife, num7);
                }
                else
                {
                    toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.RestoresLife", item.healLife);
                }
                numLines++;
            }
            if (item.healMana > 0)
            {
                toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.RestoresMana", item.healMana);
                numLines++;
            }
            if (item.mana > 0 && (item.type != 127 || !player[myPlayer].spaceGun))
            {
                toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.UsesMana", (int)((float)item.mana * player[myPlayer].manaCost));
                numLines++;
            }
            if (item.createWall > 0 || item.createTile > -1)
            {
                if (item.type != 213 && item.type != 5295 && item.tileWand < 1)
                {
                    toolTipLine[numLines] = Lang.tip[33].Value;
                    numLines++;
                }
            }
            else if (item.ammo > 0 && !item.notAmmo)
            {
                toolTipLine[numLines] = Lang.tip[34].Value;
                numLines++;
            }
            else if (item.consumable && !item.chlorophyteExtractinatorConsumable)
            {
                toolTipLine[numLines] = Lang.tip[35].Value;
                numLines++;
            }
            if (item.material)
            {
                toolTipLine[numLines] = Lang.tip[36].Value;
                numLines++;
            }
            if (item.ToolTip != null)
            {
                for (int i = 0; i < item.ToolTip.Lines; i++)
                {
                    if (i == 0 && ItemID.Sets.UsesCursedByPlanteraTooltip[item.type] && !NPC.downedPlantBoss)
                    {
                        toolTipLine[numLines] = Lang.tip[59].Value;
                        numLines++;
                    }
                    else
                    {
                        toolTipLine[numLines] = item.ToolTip.GetLine(i);
                        numLines++;
                    }
                }
            }
            if (tenthAnniversaryWorld && item.type == 238)
            {
                toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.WizardHatDuringAnniversary");
                numLines++;
            }
            if (getGoodWorld && remixWorld)
            {
                if (item.type == 556 || item.type == 557 || item.type == 544)
                {
                    numLines--;
                    toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.MechSummonDuringEverything");
                    numLines++;
                }
            }
            else if (item.type == 5334)
            {
                numLines--;
                toolTipLine[numLines] = "";
                numLines--;
                toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.MechdusaSummonNotDuringEverything");
                numLines++;
            }
            if ((item.type == 3818 || item.type == 3819 || item.type == 3820 || item.type == 3824 || item.type == 3825 || item.type == 3826 || item.type == 3829 || item.type == 3830 || item.type == 3831 || item.type == 3832 || item.type == 3833 || item.type == 3834) && !player[myPlayer].downedDD2EventAnyDifficulty)
            {
                toolTipLine[numLines] = Lang.misc[104].Value;
                numLines++;
            }
            if (item.buffType > 0 && BuffID.Sets.IsWellFed[item.buffType] && expertMode)
            {
                toolTipLine[numLines] = Lang.misc[40].Value;
                numLines++;
            }
            if (item.buffTime > 0)
            {
                string text = ((item.buffTime / 60 < 60) ? Language.GetTextValue("CommonItemTooltip.SecondDuration", Math.Round((double)item.buffTime / 60.0)) : Language.GetTextValue("CommonItemTooltip.MinuteDuration", Math.Round((double)(item.buffTime / 60) / 60.0)));
                toolTipLine[numLines] = text;
                numLines++;
            }
            if (item.type == 3262 || item.type == 3282 || item.type == 3283 || item.type == 3284 || item.type == 3285 || item.type == 3286 || item.type == 3316 || item.type == 3315 || item.type == 3317 || item.type == 3291 || item.type == 3389)
            {
                toolTipLine[numLines] = " ";
                yoyoLogo = numLines;
                numLines++;
            }
            if (item.prefix > 0)
            {
                Item item2 = tooltipPrefixComparisonItem;
                if (item2 == null || item2.netID != item.netID)
                {
                    item2 = new Item();
                    item2.netDefaults(item.netID);
                }
                if (item2.damage != item.damage)
                {
                    double num8 = (float)item.damage - (float)item2.damage;
                    num8 = num8 / (double)item2.damage * 100.0;
                    num8 = Math.Round(num8);
                    if (num8 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num8 + Lang.tip[39].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num8 + Lang.tip[39].Value;
                    }
                    if (num8 < 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item2.useAnimation != item.useAnimation)
                {
                    double num9 = (float)item.useAnimation - (float)item2.useAnimation;
                    num9 = num9 / (double)item2.useAnimation * 100.0;
                    num9 = Math.Round(num9);
                    num9 *= -1.0;
                    if (num9 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num9 + Lang.tip[40].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num9 + Lang.tip[40].Value;
                    }
                    if (num9 < 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item2.crit != item.crit)
                {
                    double num10 = (float)item.crit - (float)item2.crit;
                    if (num10 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num10 + Lang.tip[41].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num10 + Lang.tip[41].Value;
                    }
                    if (num10 < 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item2.mana != item.mana)
                {
                    double num11 = (float)item.mana - (float)item2.mana;
                    num11 = num11 / (double)item2.mana * 100.0;
                    num11 = Math.Round(num11);
                    if (num11 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num11 + Lang.tip[42].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num11 + Lang.tip[42].Value;
                    }
                    if (num11 > 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item2.scale != item.scale)
                {
                    double num12 = item.scale - item2.scale;
                    num12 = num12 / (double)item2.scale * 100.0;
                    num12 = Math.Round(num12);
                    if (num12 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num12 + Lang.tip[43].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num12 + Lang.tip[43].Value;
                    }
                    if (num12 < 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item2.shootSpeed != item.shootSpeed)
                {
                    double num13 = item.shootSpeed - item2.shootSpeed;
                    num13 = num13 / (double)item2.shootSpeed * 100.0;
                    num13 = Math.Round(num13);
                    if (num13 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num13 + Lang.tip[44].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num13 + Lang.tip[44].Value;
                    }
                    if (num13 < 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item2.knockBack != oldKB)
                {
                    double num14 = oldKB - item2.knockBack;
                    num14 = num14 / (double)item2.knockBack * 100.0;
                    num14 = Math.Round(num14);
                    if (num14 > 0.0)
                    {
                        toolTipLine[numLines] = "+" + num14 + Lang.tip[45].Value;
                    }
                    else
                    {
                        toolTipLine[numLines] = num14 + Lang.tip[45].Value;
                    }
                    if (num14 < 0.0)
                    {
                        badPreFixLine[numLines] = true;
                    }
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 62)
                {
                    toolTipLine[numLines] = "+1" + Lang.tip[25].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 63)
                {
                    toolTipLine[numLines] = "+2" + Lang.tip[25].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 64)
                {
                    toolTipLine[numLines] = "+3" + Lang.tip[25].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 65)
                {
                    toolTipLine[numLines] = "+4" + Lang.tip[25].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 66)
                {
                    toolTipLine[numLines] = "+20 " + Lang.tip[31].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 67)
                {
                    toolTipLine[numLines] = "+2" + Lang.tip[5].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 68)
                {
                    toolTipLine[numLines] = "+4" + Lang.tip[5].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 69)
                {
                    toolTipLine[numLines] = "+1" + Lang.tip[39].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 70)
                {
                    toolTipLine[numLines] = "+2" + Lang.tip[39].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 71)
                {
                    toolTipLine[numLines] = "+3" + Lang.tip[39].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 72)
                {
                    toolTipLine[numLines] = "+4" + Lang.tip[39].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 73)
                {
                    toolTipLine[numLines] = "+1" + Lang.tip[46].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 74)
                {
                    toolTipLine[numLines] = "+2" + Lang.tip[46].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 75)
                {
                    toolTipLine[numLines] = "+3" + Lang.tip[46].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 76)
                {
                    toolTipLine[numLines] = "+4" + Lang.tip[46].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 77)
                {
                    toolTipLine[numLines] = "+1" + Lang.tip[47].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 78)
                {
                    toolTipLine[numLines] = "+2" + Lang.tip[47].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 79)
                {
                    toolTipLine[numLines] = "+3" + Lang.tip[47].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
                if (item.prefix == 80)
                {
                    toolTipLine[numLines] = "+4" + Lang.tip[47].Value;
                    preFixLine[numLines] = true;
                    numLines++;
                }
            }
            if (item.wornArmor && player[myPlayer].setBonus != "")
            {
                toolTipLine[numLines] = Lang.tip[48].Value + " " + player[myPlayer].setBonus;
                numLines++;
            }
        }
        if (item.expert)
        {
            toolTipLine[numLines] = Language.GetTextValue("GameUI.Expert");
            numLines++;
        }
        if (item.rare == -13)
        {
            toolTipLine[numLines] = Language.GetTextValue("GameUI.Master");
            numLines++;
        }
        if ((item.tooltipContext == 0 || item.tooltipContext == 2 || item.tooltipContext == 1 || item.tooltipContext == 3 || item.tooltipContext == 4 || item.tooltipContext == 32 || item.tooltipContext == 15 || item.tooltipContext == 6 || item.tooltipContext == 22 || item.tooltipContext == 7 || item.tooltipContext == 5) && LocalPlayer.difficulty == 3 && CreativeItemSacrificesCatalog.Instance.TryGetSacrificeCountCapToUnlockInfiniteItems(item.type, out var amountNeeded))
        {
            int sacrificeCount = LocalPlayerCreativeTracker.ItemSacrifices.GetSacrificeCount(item.type);
            if (amountNeeded - sacrificeCount > 0)
            {
                toolTipLine[numLines] = Language.GetTextValue("CommonItemTooltip.CreativeSacrificeNeeded", amountNeeded - sacrificeCount);
                researchLine = numLines;
                numLines++;
            }
        }
        string bestiaryNotes = item.BestiaryNotes;
        if (!string.IsNullOrWhiteSpace(bestiaryNotes))
        {
            string[] array = bestiaryNotes.Split('\n');
            foreach (string text2 in array)
            {
                toolTipLine[numLines++] = text2;
            }
        }
    }
 
    private void MouseText_DrawBuffTooltip(string buffString, ref int X, ref int Y)
    {
        Microsoft.Xna.Framework.Point p = new Microsoft.Xna.Framework.Point(X, Y);
        int num = 220;
        int num2 = 72;
        int num3 = -1;
        float num4 = 1f;
        List<Vector2> list = new List<Vector2>();
        Vector2 vector = FontAssets.MouseText.Value.MeasureString(buffString);
        list.Add(vector);
        int num5 = (int)((float)(screenHeight - Y - 24 - num2) * num4) / 20;
        if (num5 < 1)
        {
            num5 = 1;
        }
        if (bannerMouseOver)
        {
            int num6 = 0;
            for (int i = 0; i < 290; i++)
            {
                if (Item.BannerToNPC(i) != 0 && player[myPlayer].HasNPCBannerBuff(i))
                {
                    num6++;
                    string nPCNameValue = Lang.GetNPCNameValue(Item.BannerToNPC(i));
                    Vector2 vector2 = FontAssets.MouseText.Value.MeasureString(nPCNameValue);
                    int num7 = X;
                    int num8 = Y + (int)vector2.Y + num6 * 20 + 10;
                    int num9 = 0;
                    int num10 = num6 / num5;
                    for (int j = 0; j < num10; j++)
                    {
                        num9++;
                        num7 += num;
                        num8 -= num5 * 20;
                    }
                    if ((float)(num7 - 24 - num) > (float)screenWidth * num4)
                    {
                        num3 = num6;
                        break;
                    }
                    list.Add(new Vector2(num7, num8) + vector2 - p.ToVector2());
                }
            }
        }
        Vector2 zero = Vector2.Zero;
        foreach (Vector2 item in list)
        {
            if (zero.X < item.X)
            {
                zero.X = item.X;
            }
            if (zero.Y < item.Y)
            {
                zero.Y = item.Y;
            }
        }
        if ((float)X + zero.X + 24f > (float)screenWidth * num4)
        {
            X = (int)((float)screenWidth * num4 - zero.X - 24f);
        }
        if ((float)Y + zero.Y + 4f > (float)screenHeight * num4)
        {
            Y = (int)((float)screenHeight * num4 - zero.Y - 4f);
        }
        for (int k = 0; k < 5; k++)
        {
            int num11 = X;
            int num12 = Y + (int)FontAssets.MouseText.Value.MeasureString(buffString).Y;
            Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Black;
            switch (k)
            {
            case 0:
                num11 -= 2;
                break;
            case 1:
                num11 += 2;
                break;
            case 2:
                num12 -= 2;
                break;
            case 3:
                num12 += 2;
                break;
            default:
                color = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
                break;
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, buffString, new Vector2(num11, num12), color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        if (!bannerMouseOver)
        {
            return;
        }
        int num13 = 0;
        for (int l = 0; l < 290; l++)
        {
            if (Item.BannerToNPC(l) == 0 || !player[myPlayer].HasNPCBannerBuff(l))
            {
                continue;
            }
            num13++;
            bool flag = false;
            for (int m = 0; m < 5; m++)
            {
                int num14 = X;
                int num15 = Y + (int)vector.Y + num13 * 20 + 10;
                int num16 = (num13 - 1) / num5;
                num14 += num * num16;
                num15 -= num5 * 20 * num16;
                string text = Lang.GetNPCNameValue(Item.BannerToNPC(l));
                if (num3 == num13)
                {
                    text = Language.GetTextValue("UI.Ellipsis");
                    flag = true;
                }
                Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Black;
                switch (m)
                {
                case 0:
                    num14 -= 2;
                    break;
                case 1:
                    num14 += 2;
                    break;
                case 2:
                    num15 -= 2;
                    break;
                case 3:
                    num15 += 2;
                    break;
                default:
                {
                    float num17 = (float)(int)mouseTextColor / 255f;
                    color2 = new Microsoft.Xna.Framework.Color((byte)(80f * num17), (byte)(255f * num17), (byte)(120f * num17), mouseTextColor);
                    break;
                }
                }
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(num14, num15), color2, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (flag)
            {
                break;
            }
        }
    }
 
    protected void DrawFPS()
    {
        if (showFrameRate)
        {
            string text = string.Concat(frameRate);
            text = text + " (" + (Liquid.numLiquid + LiquidBuffer.numLiquidBuffer) + ")";
            text = text + " (" + (int)(gfxQuality * 100f) + "%)";
            string text2 = text + " " + debugWords;
            int num = 4;
            if (!gameMenu)
            {
                num = screenHeight - 24;
            }
            Vector2 vector = new Vector2(4f, num);
            Vector2 vector2 = new Vector2(0f, 0f);
            Vector2 vector3 = FontAssets.MouseText.Value.MeasureString(text2);
            if (PlayerInput.SettingsForUI.ShowGamepadHints && !gameMenu)
            {
                vector.X = (float)(screenWidth - 4) - vector3.X;
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text2, vector, new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, vector2, 1f, SpriteEffects.None, 0f);
        }
    }
 
    public static void DrawGamepadInstructions()
    {
        if (drawingPlayerChat || !PlayerInput.SettingsForUI.ShowGamepadHints)
        {
            return;
        }
        string text = PlayerInput.ComposeInstructionsForGamepad();
        PlayerInput.AllowExecutionOfGamepadInstructions = false;
        if (!GamepadDisableInstructionsDisplay && text.Length > 0 && (!player[myPlayer].dead || gameMenu))
        {
            float num = 35f;
            float num2 = 1f;
            Vector2 baseScale = new Vector2(num2);
            if (gameMenu)
            {
                num = 55f;
            }
            if (menuMode == 0)
            {
                num += 32f;
            }
            Vector2 stringSize = ChatManager.GetStringSize(FontAssets.MouseText.Value, text, new Vector2(1f));
            float t = num2;
            Utils.Swap(ref GlyphTagHandler.GlyphsScale, ref t);
            ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(12f, (float)screenHeight - num) - stringSize * new Vector2(0f, 0f), Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, baseScale, -1f, num2 * 2f);
            Utils.Swap(ref GlyphTagHandler.GlyphsScale, ref t);
        }
    }
 
    public static Microsoft.Xna.Framework.Color shine(Microsoft.Xna.Framework.Color newColor, int type)
    {
        int num = newColor.R;
        int num2 = newColor.G;
        int num3 = newColor.B;
        float num4 = 0.6f;
        switch (type)
        {
        case 25:
            num = (int)((float)(int)newColor.R * 0.95f);
            num2 = (int)((float)(int)newColor.G * 0.85f);
            num3 = (int)((double)(int)newColor.B * 1.1);
            break;
        case 117:
            num = (int)((float)(int)newColor.R * 1.1f);
            num2 = (int)((float)(int)newColor.G * 1f);
            num3 = (int)((double)(int)newColor.B * 1.2);
            break;
        case 204:
            num4 = 0.3f + (float)(int)mouseTextColor / 300f;
            num = (int)((float)(int)newColor.R * (1.3f * num4));
            if (num > 255)
            {
                num = 255;
            }
            return new Microsoft.Xna.Framework.Color(num, num2, num3, 255);
        case 211:
            num4 = 0.3f + (float)(int)mouseTextColor / 300f;
            num2 = (int)((float)(int)newColor.G * (1.5f * num4));
            num3 = (int)((float)(int)newColor.B * (1.1f * num4));
            break;
        case 147:
        case 161:
            num = (int)((float)(int)newColor.R * 1.1f);
            num2 = (int)((float)(int)newColor.G * 1.12f);
            num3 = (int)((double)(int)newColor.B * 1.15);
            break;
        case 163:
            num = (int)((float)(int)newColor.R * 1.05f);
            num2 = (int)((float)(int)newColor.G * 1.1f);
            num3 = (int)((double)(int)newColor.B * 1.15);
            break;
        case 164:
            num = (int)((float)(int)newColor.R * 1.1f);
            num2 = (int)((float)(int)newColor.G * 1.1f);
            num3 = (int)((double)(int)newColor.B * 1.2);
            break;
        case 178:
            num4 = 0.5f;
            num = (int)((float)(int)newColor.R * (1f + num4));
            num2 = (int)((float)(int)newColor.G * (1f + num4));
            num3 = (int)((float)(int)newColor.B * (1f + num4));
            break;
        case 185:
        case 186:
            num4 = 0.3f;
            num = (int)((float)(int)newColor.R * (1f + num4));
            num2 = (int)((float)(int)newColor.G * (1f + num4));
            num3 = (int)((float)(int)newColor.B * (1f + num4));
            break;
        case 262:
        case 263:
        case 264:
        case 265:
        case 266:
        case 267:
        case 268:
            num3 += 100;
            num += 100;
            num2 += 100;
            break;
        default:
            if (tileShine2[type])
            {
                num = (int)((float)(int)newColor.R * (1f + num4));
                num2 = (int)((float)(int)newColor.G * (1f + num4));
                num3 = (int)((float)(int)newColor.B * (1f + num4));
            }
            break;
        }
        float num5 = shimmerAlpha;
        if (num5 > 0f)
        {
            num = (int)((float)num * (1f - num5) + (float)num * shimmerShine.X * num5);
            num2 = (int)((float)num2 * (1f - num5) + (float)num2 * shimmerShine.Y * num5);
            num3 = (int)((float)num3 * (1f - num5) + (float)num3 * shimmerShine.Z * num5);
        }
        if (num > 255)
        {
            num = 255;
        }
        if (num2 > 255)
        {
            num2 = 255;
        }
        if (num3 > 255)
        {
            num3 = 255;
        }
        newColor.R = (byte)num;
        newColor.G = (byte)num2;
        newColor.B = (byte)num3;
        return new Microsoft.Xna.Framework.Color((byte)num, (byte)num2, (byte)num3, newColor.A);
    }
 
    public static void shine(ref Vector3 newColor, int type)
    {
        float num = 0.6f;
        switch (type)
        {
        case 25:
            newColor.X *= 0.95f;
            newColor.Y *= 0.85f;
            newColor.Z *= 1.1f;
            break;
        case 117:
            newColor.X *= 1.1f;
            newColor.Z *= 1.2f;
            break;
        case 204:
            num = 0.3f + (float)(int)mouseTextColor / 300f;
            newColor.X *= 1.3f * num;
            break;
        case 211:
            num = 0.3f + (float)(int)mouseTextColor / 300f;
            newColor.Y *= 1.5f * num;
            newColor.Z *= 1.1f * num;
            break;
        case 147:
        case 161:
            newColor.X *= 1.1f;
            newColor.Y *= 1.12f;
            newColor.Z *= 1.15f;
            break;
        case 163:
            newColor.X *= 1.05f;
            newColor.Y *= 1.1f;
            newColor.Z *= 1.15f;
            break;
        case 164:
            newColor.X *= 1.1f;
            newColor.Y *= 1.1f;
            newColor.Z *= 1.2f;
            break;
        case 178:
            num = 0.5f;
            newColor.X *= 1f + num;
            newColor.Y *= 1f + num;
            newColor.Z *= 1f + num;
            break;
        case 185:
        case 186:
            num = 0.3f;
            newColor.X *= 1f + num;
            newColor.Y *= 1f + num;
            newColor.Z *= 1f + num;
            break;
        case 262:
        case 263:
        case 264:
        case 265:
        case 266:
        case 267:
        case 268:
            newColor.X += 0.39f;
            newColor.Y += 0.39f;
            newColor.Z += 0.39f;
            break;
        default:
            if (tileShine2[type])
            {
                newColor.X *= 1f + num;
                newColor.Y *= 1f + num;
                newColor.Z *= 1f + num;
            }
            break;
        }
        float num2 = shimmerAlpha;
        if (num2 > 0f)
        {
            shimmerShine.X = 1.2f;
            shimmerShine.Y = 1f;
            shimmerShine.Z = 1.6f;
            newColor.X = newColor.X * (1f - num2) + newColor.X * shimmerShine.X * num2;
            newColor.Y = newColor.Y * (1f - num2) + newColor.Y * shimmerShine.Y * num2;
            newColor.Z = newColor.Z * (1f - num2) + newColor.Z * shimmerShine.Z * num2;
            if (newColor.X > 1f)
            {
                newColor.X = 1f;
            }
            if (newColor.Y > 1f)
            {
                newColor.Y = 1f;
            }
            if (newColor.Z > 1f)
            {
                newColor.Z = 1f;
            }
        }
    }
 
    private void DrawTileEntities(bool solidLayer, bool overRenderTargets, bool intoRenderTargets)
    {
        TilesRenderer.PostDrawTiles(solidLayer, overRenderTargets, intoRenderTargets);
    }
 
    public void ClearCachedTileDraws()
    {
        TilesRenderer.ClearCachedTileDraws(solidLayer: false);
        TilesRenderer.ClearCachedTileDraws(solidLayer: true);
    }
 
    public void ResetAllContentBasedRenderTargets()
    {
        TilePaintSystem.Reset();
        for (int i = 0; i < ContentThatNeedsRenderTargets.Count; i++)
        {
            ContentThatNeedsRenderTargets[i].Reset();
        }
    }
 
    public static bool IsTileSpelunkable(Tile t)
    {
        return IsTileSpelunkable(t.type, t.frameX, t.frameY);
    }
 
    public static bool IsTileSpelunkable(ushort typeCache, short tileFrameX, short tileFrameY)
    {
        if (tileSpelunker[typeCache])
        {
            return true;
        }
        if (typeCache == 185 && tileFrameY == 18 && tileFrameX >= 576 && tileFrameX <= 882)
        {
            return true;
        }
        if (typeCache == 186 && tileFrameX >= 864 && tileFrameX <= 1170)
        {
            return true;
        }
        return false;
    }
 
    public static bool IsTileBiomeSightable(ushort type, short tileFrameX, short tileFrameY, ref Microsoft.Xna.Framework.Color sightColor)
    {
        if (TileID.Sets.CorruptBiomeSight[type] || (remixWorld && type == 474))
        {
            sightColor = new Microsoft.Xna.Framework.Color(200, 100, 240);
            return true;
        }
        if (TileID.Sets.CrimsonBiomeSight[type] || (remixWorld && type == 195))
        {
            sightColor = new Microsoft.Xna.Framework.Color(255, 100, 100);
            return true;
        }
        if (TileID.Sets.HallowBiomeSight[type])
        {
            sightColor = new Microsoft.Xna.Framework.Color(255, 160, 240);
            return true;
        }
        return false;
    }
 
    protected void DrawTiles(bool solidLayer, bool forRenderTargets, bool intoRenderTargets, int waterStyleOverride = -1)
    {
        TilesRenderer.Draw(solidLayer, forRenderTargets, intoRenderTargets, waterStyleOverride);
    }
 
    protected void DrawGoreBehind()
    {
        for (int i = 0; i < 600; i++)
        {
            if (!gore[i].active || gore[i].type <= 0)
            {
                continue;
            }
            bool flag = false;
            if (((gore[i].type >= 706 && gore[i].type <= 717) || gore[i].type == 943 || gore[i].type == 1147 || (gore[i].type >= 1160 && gore[i].type <= 1162)) && (gore[i].frame < 7 || gore[i].frame > 9))
            {
                flag = true;
            }
            if (flag)
            {
                LoadGore(gore[i].type);
                if (gore[i].Frame.ColumnCount > 1 || gore[i].Frame.RowCount > 1)
                {
                    Microsoft.Xna.Framework.Rectangle sourceRectangle = gore[i].Frame.GetSourceRectangle(TextureAssets.Gore[gore[i].type].Value);
                    Microsoft.Xna.Framework.Color alpha = gore[i].GetAlpha(Lighting.GetColor((int)((double)gore[i].position.X + (double)sourceRectangle.Width * 0.5) / 16, (int)(((double)gore[i].position.Y + (double)sourceRectangle.Height * 0.5) / 16.0)));
                    spriteBatch.Draw(TextureAssets.Gore[gore[i].type].Value, new Vector2(gore[i].position.X - screenPosition.X + (float)(sourceRectangle.Width / 2), gore[i].position.Y - screenPosition.Y + (float)(sourceRectangle.Height / 2) - 2f), sourceRectangle, alpha, gore[i].rotation, new Vector2(sourceRectangle.Width / 2, sourceRectangle.Height / 2), gore[i].scale, SpriteEffects.None, 0f);
                }
                else
                {
                    Microsoft.Xna.Framework.Color alpha2 = gore[i].GetAlpha(Lighting.GetColor((int)((double)gore[i].position.X + (double)TextureAssets.Gore[gore[i].type].Width() * 0.5) / 16, (int)(((double)gore[i].position.Y + (double)TextureAssets.Gore[gore[i].type].Height() * 0.5) / 16.0)));
                    spriteBatch.Draw(TextureAssets.Gore[gore[i].type].Value, new Vector2(gore[i].position.X - screenPosition.X + (float)(TextureAssets.Gore[gore[i].type].Width() / 2), gore[i].position.Y - screenPosition.Y + (float)(TextureAssets.Gore[gore[i].type].Height() / 2)), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Gore[gore[i].type].Width(), TextureAssets.Gore[gore[i].type].Height()), alpha2, gore[i].rotation, new Vector2(TextureAssets.Gore[gore[i].type].Width() / 2, TextureAssets.Gore[gore[i].type].Height() / 2), gore[i].scale, SpriteEffects.None, 0f);
                }
            }
        }
    }
 
    protected void DrawGore()
    {
        drawBackGore = false;
        for (int i = 0; i < 600; i++)
        {
            if (!gore[i].active || gore[i].type <= 0)
            {
                continue;
            }
            if (((gore[i].type >= 706 && gore[i].type <= 717) || gore[i].type == 943 || gore[i].type == 1147 || (gore[i].type >= 1160 && gore[i].type <= 1162)) && (gore[i].frame < 7 || gore[i].frame > 9))
            {
                drawBackGore = true;
                continue;
            }
            LoadGore(gore[i].type);
            if (gore[i].Frame.ColumnCount > 1 || gore[i].Frame.RowCount > 1)
            {
                Microsoft.Xna.Framework.Rectangle sourceRectangle = gore[i].Frame.GetSourceRectangle(TextureAssets.Gore[gore[i].type].Value);
                Vector2 vector = new Vector2(0f, 0f);
                if (gore[i].type == 1217)
                {
                    vector.Y += 4f;
                }
                Microsoft.Xna.Framework.Color alpha = gore[i].GetAlpha(Lighting.GetColor((int)((double)gore[i].position.X + (double)sourceRectangle.Width * 0.5) / 16, (int)(((double)gore[i].position.Y + (double)sourceRectangle.Height * 0.5) / 16.0)));
                spriteBatch.Draw(TextureAssets.Gore[gore[i].type].Value, new Vector2(gore[i].position.X - screenPosition.X + (float)(sourceRectangle.Width / 2), gore[i].position.Y - screenPosition.Y + (float)(sourceRectangle.Height / 2) - 2f) + vector, sourceRectangle, alpha, gore[i].rotation, new Vector2(sourceRectangle.Width / 2, sourceRectangle.Height / 2), gore[i].scale, SpriteEffects.None, 0f);
            }
            else
            {
                Microsoft.Xna.Framework.Color alpha2 = gore[i].GetAlpha(Lighting.GetColor((int)((double)gore[i].position.X + (double)TextureAssets.Gore[gore[i].type].Width() * 0.5) / 16, (int)(((double)gore[i].position.Y + (double)TextureAssets.Gore[gore[i].type].Height() * 0.5) / 16.0)));
                spriteBatch.Draw(TextureAssets.Gore[gore[i].type].Value, new Vector2(gore[i].position.X - screenPosition.X + (float)(TextureAssets.Gore[gore[i].type].Width() / 2), gore[i].position.Y - screenPosition.Y + (float)(TextureAssets.Gore[gore[i].type].Height() / 2)), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Gore[gore[i].type].Width(), TextureAssets.Gore[gore[i].type].Height()), alpha2, gore[i].rotation, new Vector2(TextureAssets.Gore[gore[i].type].Width() / 2, TextureAssets.Gore[gore[i].type].Height() / 2), gore[i].scale, SpriteEffects.None, 0f);
            }
        }
        TimeLogger.DetailedDrawTime(24);
    }
 
    public void DrawHealthBar(float X, float Y, int Health, int MaxHealth, float alpha, float scale = 1f, bool noFlip = false)
    {
        if (Health <= 0)
        {
            return;
        }
        float num = (float)Health / (float)MaxHealth;
        if (num > 1f)
        {
            num = 1f;
        }
        int num2 = (int)(36f * num);
        float num3 = X - 18f * scale;
        float num4 = Y;
        if (player[myPlayer].gravDir == -1f && !noFlip)
        {
            num4 -= screenPosition.Y;
            num4 = screenPosition.Y + (float)screenHeight - num4;
        }
        float num5 = 0f;
        float num6 = 0f;
        float num7 = 0f;
        float num8 = 255f;
        num -= 0.1f;
        if ((double)num > 0.5)
        {
            num6 = 255f;
            num5 = 255f * (1f - num) * 2f;
        }
        else
        {
            num6 = 255f * num * 2f;
            num5 = 255f;
        }
        float num9 = 0.95f;
        num5 = num5 * alpha * num9;
        num6 = num6 * alpha * num9;
        num8 = num8 * alpha * num9;
        if (num5 < 0f)
        {
            num5 = 0f;
        }
        if (num5 > 255f)
        {
            num5 = 255f;
        }
        if (num6 < 0f)
        {
            num6 = 0f;
        }
        if (num6 > 255f)
        {
            num6 = 255f;
        }
        if (num8 < 0f)
        {
            num8 = 0f;
        }
        if (num8 > 255f)
        {
            num8 = 255f;
        }
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color((byte)num5, (byte)num6, (byte)num7, (byte)num8);
        if (num2 < 3)
        {
            num2 = 3;
        }
        if (num2 < 34)
        {
            if (num2 < 36)
            {
                spriteBatch.Draw(TextureAssets.Hb2.Value, new Vector2(num3 - screenPosition.X + (float)num2 * scale, num4 - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(2, 0, 2, TextureAssets.Hb2.Height()), color, 0f, new Vector2(0f, 0f), scale, SpriteEffects.None, 0f);
            }
            if (num2 < 34)
            {
                spriteBatch.Draw(TextureAssets.Hb2.Value, new Vector2(num3 - screenPosition.X + (float)(num2 + 2) * scale, num4 - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(num2 + 2, 0, 36 - num2 - 2, TextureAssets.Hb2.Height()), color, 0f, new Vector2(0f, 0f), scale, SpriteEffects.None, 0f);
            }
            if (num2 > 2)
            {
                spriteBatch.Draw(TextureAssets.Hb1.Value, new Vector2(num3 - screenPosition.X, num4 - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, num2 - 2, TextureAssets.Hb1.Height()), color, 0f, new Vector2(0f, 0f), scale, SpriteEffects.None, 0f);
            }
            spriteBatch.Draw(TextureAssets.Hb1.Value, new Vector2(num3 - screenPosition.X + (float)(num2 - 2) * scale, num4 - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(32, 0, 2, TextureAssets.Hb1.Height()), color, 0f, new Vector2(0f, 0f), scale, SpriteEffects.None, 0f);
        }
        else
        {
            if (num2 < 36)
            {
                spriteBatch.Draw(TextureAssets.Hb2.Value, new Vector2(num3 - screenPosition.X + (float)num2 * scale, num4 - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(num2, 0, 36 - num2, TextureAssets.Hb2.Height()), color, 0f, new Vector2(0f, 0f), scale, SpriteEffects.None, 0f);
            }
            spriteBatch.Draw(TextureAssets.Hb1.Value, new Vector2(num3 - screenPosition.X, num4 - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, num2, TextureAssets.Hb1.Height()), color, 0f, new Vector2(0f, 0f), scale, SpriteEffects.None, 0f);
        }
    }
 
    public static float NPCAddHeight(NPC theNPC)
    {
        float num = 0f;
        if (theNPC.type == 125)
        {
            num = 30f;
        }
        else if (theNPC.type == 54)
        {
            num = 2f;
        }
        else if (theNPC.type == 205)
        {
            num = 8f;
        }
        else if (theNPC.type == 182)
        {
            num = 24f;
        }
        else if (theNPC.type == 178)
        {
            num = 2f;
        }
        else if (theNPC.type == 126)
        {
            num = 30f;
        }
        else if (theNPC.type == 6 || theNPC.type == 173)
        {
            num = 26f;
        }
        else if (theNPC.type == 94)
        {
            num = 14f;
        }
        else if (theNPC.type == 7 || theNPC.type == 8 || theNPC.type == 9)
        {
            num = 13f;
        }
        else if (theNPC.type == 98 || theNPC.type == 99 || theNPC.type == 100)
        {
            num = 13f;
        }
        else if (theNPC.type == 95 || theNPC.type == 96 || theNPC.type == 97)
        {
            num = 13f;
        }
        else if (theNPC.type == 10 || theNPC.type == 11 || theNPC.type == 12)
        {
            num = 8f;
        }
        else if (theNPC.type == 13 || theNPC.type == 14 || theNPC.type == 15)
        {
            num = 26f;
        }
        else if (theNPC.type == 175)
        {
            num = 4f;
        }
        else if (theNPC.type == 520)
        {
            num = 2f;
        }
        else if (theNPC.type >= 412 && theNPC.type <= 414)
        {
            num = 18f;
        }
        else if (theNPC.type == 48)
        {
            num = 32f;
        }
        else if (theNPC.type == 49 || theNPC.type == 51)
        {
            num = 4f;
        }
        else if (theNPC.type == 60)
        {
            num = 10f;
        }
        else if (theNPC.type == 62 || theNPC.type == 66 || theNPC.type == 156)
        {
            num = 14f;
        }
        else if (theNPC.type == 63 || theNPC.type == 64 || theNPC.type == 103)
        {
            num = 4f;
        }
        else if (theNPC.type == 65)
        {
            num = 5f;
        }
        else if (theNPC.type == 69)
        {
            num = 4f;
        }
        else if (theNPC.type == 70)
        {
            num = -4f;
        }
        else if (theNPC.type == 72)
        {
            num = -2f;
        }
        else if (theNPC.type == 83 || theNPC.type == 84)
        {
            num = 20f;
        }
        else if (theNPC.type == 150 || theNPC.type == 151 || theNPC.type == 158)
        {
            num = 10f;
        }
        else if (theNPC.type == 152)
        {
            num = 6f;
        }
        else if (theNPC.type == 153 || theNPC.type == 154)
        {
            num = 2f;
        }
        else if (theNPC.type == 165 || theNPC.type == 237 || theNPC.type == 238 || theNPC.type == 240 || theNPC.type == 531)
        {
            num = 10f;
        }
        else if (theNPC.type == 39 || theNPC.type == 40 || theNPC.type == 41)
        {
            num = 26f;
        }
        else if (theNPC.type >= 87 && theNPC.type <= 92)
        {
            num = 56f;
        }
        else if (theNPC.type >= 134 && theNPC.type <= 136)
        {
            num = 30f;
        }
        else if (theNPC.type == 169)
        {
            num = 8f;
        }
        else if (theNPC.type == 174)
        {
            num = 6f;
        }
        else if (theNPC.type == 369)
        {
            num = 2f;
        }
        else if (theNPC.type == 376)
        {
            num = 6f;
        }
        else if (theNPC.type == 579)
        {
            num = -2f;
        }
        else if (theNPC.type == 613 || theNPC.type == 612)
        {
            num = 2f;
        }
        switch (theNPC.type)
        {
        case 269:
        case 270:
        case 271:
        case 274:
        case 277:
            num -= 2f;
            break;
        }
        if (theNPC.townNPC && theNPC.ai[0] == 5f)
        {
            num -= 4f;
            if (theNPC.type == 637 || theNPC.type == 656 || NPCID.Sets.IsTownSlime[theNPC.type])
            {
                num -= 10f;
            }
        }
        if (theNPC.type == 671 || theNPC.type == 672 || theNPC.type == 673 || theNPC.type == 674 || theNPC.type == 675)
        {
            num += 10f;
        }
        return num * theNPC.scale;
    }
 
    protected void DrawProjectiles()
    {
        PlayerInput.SetZoom_MouseInWorld();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        int num = 0;
        CurrentDrawnEntity = null;
        CurrentDrawnEntityShader = 0;
        if (ignoreErrors)
        {
            for (int i = 0; i < 1000; i++)
            {
                if (projectile[i].active && projectile[i].type > 0 && !projectile[i].hide)
                {
                    num++;
                    try
                    {
                        DrawProj(i);
                    }
                    catch (Exception e)
                    {
                        TimeLogger.DrawException(e);
                        projectile[i].active = false;
                    }
                }
            }
        }
        else
        {
            for (int j = 0; j < 1000; j++)
            {
                if (projectile[j].active && projectile[j].type > 0 && !projectile[j].hide)
                {
                    DrawProj(j);
                }
            }
        }
        CurrentDrawnEntity = null;
        CurrentDrawnEntityShader = 0;
        spriteBatch.End();
        TimeLogger.DetailedDrawTime(20);
    }
 
    public static int GetProjectileDesiredShader(Projectile proj)
    {
        int result = 0;
        if (proj.minion && proj.owner != 255)
        {
            result = player[proj.owner].cMinion;
        }
        if (projHook[proj.type] && proj.owner != 255)
        {
            result = player[proj.owner].cGrapple;
        }
        if (projPet[proj.type] && !proj.minion && proj.owner != 255 && proj.damage == 0 && !ProjectileID.Sets.LightPet[proj.type])
        {
            result = player[proj.owner].cPet;
        }
        if (!proj.minion && proj.owner != 255 && proj.damage == 0 && ProjectileID.Sets.LightPet[proj.type])
        {
            result = player[proj.owner].cLight;
        }
        if (proj.owner != 255)
        {
            switch (proj.type)
            {
            case 623:
            case 1020:
                result = player[proj.owner].cPet;
                break;
            case 818:
                result = player[proj.owner].cMinion;
                break;
            }
        }
        return result;
    }
 
    private void RefreshPlayerDrawOrder()
    {
        _playersThatDrawBehindNPCs.Clear();
        _playersThatDrawAfterProjectiles.Clear();
        if (gameMenu)
        {
            return;
        }
        Player player = null;
        for (int i = 0; i < 255; i++)
        {
            player = Main.player[i];
            if (i != myPlayer && player.active && !player.outOfRange)
            {
                if (player.isLockedToATile)
                {
                    _playersThatDrawBehindNPCs.Add(player);
                }
                else
                {
                    _playersThatDrawAfterProjectiles.Add(player);
                }
            }
        }
        player = LocalPlayer;
        if (player.isLockedToATile)
        {
            _playersThatDrawBehindNPCs.Add(player);
        }
        else
        {
            _playersThatDrawAfterProjectiles.Add(player);
        }
    }
 
    protected void DrawPlayers_BehindNPCs()
    {
        PotionOfReturnRenderer.DrawPlayers(Camera, _playersThatDrawBehindNPCs.Where((Player p) => p.PotionOfReturnOriginalUsePosition.HasValue));
        PlayerRenderer.DrawPlayers(Camera, _playersThatDrawBehindNPCs);
    }
 
    protected void DrawPlayers_AfterProjectiles()
    {
        PotionOfReturnRenderer.DrawPlayers(Camera, _playersThatDrawAfterProjectiles.Where((Player p) => p.PotionOfReturnOriginalUsePosition.HasValue));
        PlayerRenderer.DrawPlayers(Camera, _playersThatDrawAfterProjectiles);
    }
 
    protected void DrawElderEye(SpriteBatch spriteBatch, Vector2 worldPosition, float opacity, float scale, int frameNumber, Microsoft.Xna.Framework.Color passedColor)
    {
        Texture2D value = TextureAssets.Extra[78].Value;
        Vector2 origin = new Vector2(68f, 94f);
        Microsoft.Xna.Framework.Rectangle value2 = value.Frame(1, 8, 0, frameNumber);
        Vector2 position = worldPosition - screenPosition;
        passedColor *= opacity;
        spriteBatch.Draw(value, position, value2, passedColor, 0f, origin, scale, SpriteEffects.None, 0f);
    }
 
    protected void DrawNPCs(bool behindTiles = false)
    {
        bool flag = false;
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X - 800, (int)screenPosition.Y - 800, screenWidth + 1600, screenHeight + 1600);
        for (int num = 199; num >= 0; num--)
        {
            try
            {
                if (npc[num].active && npc[num].type > 0 && npc[num].type < NPCID.Count && !npc[num].hide)
                {
                    npc[num].position += npc[num].netOffset;
                    if (npc[num].behindTiles == behindTiles)
                    {
                        if (npc[num].type == 125 || npc[num].type == 126)
                        {
                            if (!NPC.IsMechQueenUp && !flag)
                            {
                                flag = true;
                                for (int i = 0; i < 200; i++)
                                {
                                    if (!npc[i].active || num == i || (npc[i].type != 125 && npc[i].type != 126))
                                    {
                                        continue;
                                    }
                                    float scale = npc[i].scale;
                                    float x = npc[i].Center.X;
                                    float num2 = npc[i].Bottom.Y - (float)npc[i].height * 0.5f * scale;
                                    float x2 = npc[num].Center.X;
                                    float y = npc[num].Bottom.Y - (float)npc[num].height * 0.5f * scale;
                                    Vector2 vector = new Vector2(x2, y);
                                    float num3 = x - vector.X;
                                    float num4 = num2 - vector.Y;
                                    float rotation = (float)Math.Atan2(num4, num3) - 1.57f;
                                    bool flag2 = true;
                                    float num5 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
                                    if (num5 > 2000f)
                                    {
                                        flag2 = false;
                                    }
                                    float num6 = 40f * scale;
                                    while (flag2)
                                    {
                                        num5 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
                                        if (num5 < num6)
                                        {
                                            flag2 = false;
                                            continue;
                                        }
                                        num5 = (float)TextureAssets.Chain12.Height() * scale / num5;
                                        num3 *= num5;
                                        num4 *= num5;
                                        vector.X += num3;
                                        vector.Y += num4;
                                        num3 = x - vector.X;
                                        num4 = num2 - vector.Y;
                                        Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f));
                                        spriteBatch.Draw(TextureAssets.Chain12.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain12.Width(), TextureAssets.Chain12.Height()), color, rotation, new Vector2((float)TextureAssets.Chain12.Width() * 0.5f, (float)TextureAssets.Chain12.Height() * 0.5f), scale, SpriteEffects.None, 0f);
                                    }
                                }
                            }
                        }
                        else if (npc[num].type == 263 && npc[num].aiStyle == 52 && NPC.plantBoss >= 0)
                        {
                            Vector2 vector2 = new Vector2(npc[num].position.X + (float)(npc[num].width / 2), npc[num].position.Y + (float)(npc[num].height / 2));
                            float num7 = npc[NPC.plantBoss].Center.X - vector2.X;
                            float num8 = npc[NPC.plantBoss].Center.Y - vector2.Y;
                            float rotation2 = (float)Math.Atan2(num8, num7) - 1.57f;
                            bool flag3 = true;
                            while (flag3)
                            {
                                int num9 = 16;
                                int num10 = 32;
                                float num11 = (float)Math.Sqrt(num7 * num7 + num8 * num8);
                                if (num11 < (float)num10)
                                {
                                    num9 = (int)num11 - num10 + num9;
                                    flag3 = false;
                                }
                                num11 = (float)num9 / num11;
                                num7 *= num11;
                                num8 *= num11;
                                vector2.X += num7;
                                vector2.Y += num8;
                                num7 = npc[NPC.plantBoss].Center.X - vector2.X + npc[NPC.plantBoss].netOffset.X;
                                num8 = npc[NPC.plantBoss].Center.Y - vector2.Y + npc[NPC.plantBoss].netOffset.Y;
                                Microsoft.Xna.Framework.Color color2 = Lighting.GetColor((int)vector2.X / 16, (int)(vector2.Y / 16f));
                                spriteBatch.Draw(TextureAssets.Chain26.Value, new Vector2(vector2.X - screenPosition.X, vector2.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain26.Width(), num9), color2, rotation2, new Vector2((float)TextureAssets.Chain26.Width() * 0.5f, (float)TextureAssets.Chain26.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                            }
                        }
                        else if (npc[num].type == 264 && npc[num].aiStyle == 53 && NPC.plantBoss >= 0)
                        {
                            int num12 = NPC.plantBoss;
                            if (npc[num].ai[3] > 0f)
                            {
                                num12 = (int)npc[num].ai[3] - 1;
                            }
                            Vector2 vector3 = new Vector2(npc[num].position.X + (float)(npc[num].width / 2), npc[num].position.Y + (float)(npc[num].height / 2));
                            float num13 = npc[num12].Center.X - vector3.X;
                            float num14 = npc[num12].Center.Y - vector3.Y;
                            float rotation3 = (float)Math.Atan2(num14, num13) - 1.57f;
                            bool flag4 = true;
                            while (flag4)
                            {
                                int num15 = 16;
                                int num16 = 32;
                                float num17 = (float)Math.Sqrt(num13 * num13 + num14 * num14);
                                if (num17 < (float)num16)
                                {
                                    num15 = (int)num17 - num16 + num15;
                                    flag4 = false;
                                }
                                num17 = (float)num15 / num17;
                                num13 *= num17;
                                num14 *= num17;
                                vector3.X += num13;
                                vector3.Y += num14;
                                num13 = npc[num12].Center.X - vector3.X + npc[num12].netOffset.X;
                                num14 = npc[num12].Center.Y - vector3.Y + npc[num12].netOffset.Y;
                                Microsoft.Xna.Framework.Color color3 = Lighting.GetColor((int)vector3.X / 16, (int)(vector3.Y / 16f));
                                spriteBatch.Draw(TextureAssets.Chain27.Value, new Vector2(vector3.X - screenPosition.X, vector3.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain27.Width(), num15), color3, rotation3, new Vector2((float)TextureAssets.Chain27.Width() * 0.5f, (float)TextureAssets.Chain27.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                            }
                        }
                        if (NPCID.Sets.MustAlwaysDraw[npc[num].type] || rectangle.Intersects(new Microsoft.Xna.Framework.Rectangle((int)npc[num].position.X, (int)npc[num].position.Y, npc[num].width, npc[num].height)))
                        {
                            DrawNPCCheckAlt(npc[num]);
                            DrawNPC(num, behindTiles);
                        }
                    }
                    npc[num].position -= npc[num].netOffset;
                }
            }
            catch
            {
                npc[num].active = false;
            }
        }
    }
 
    protected void DrawNPCCheckAlt(NPC n)
    {
        if (TownNPCProfiles.Instance.GetProfile(n.type, out var profile))
        {
            TextureAssets.Npc[n.type] = profile.GetTextureNPCShouldUse(n);
        }
    }
 
    protected void DrawNPC(int iNPCIndex, bool behindTiles)
    {
        NPC rCurrentNPC = npc[iNPCIndex];
        Vector2 screenPos = screenPosition;
        DrawNPCDirect(spriteBatch, rCurrentNPC, behindTiles, screenPos);
    }
 
    public void DrawNPCDirect_QueenSlimeWings(NPC rCurrentNPC, SpriteBatch mySpriteBatch, Vector2 screenPos, Vector2 drawCenter, Microsoft.Xna.Framework.Color originColor)
    {
        Texture2D value = TextureAssets.Extra[185].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 4, 0, (int)rCurrentNPC.localAI[3] / 6);
        float scale = 0.8f;
        for (int i = 0; i < 2; i++)
        {
            float x = 1f;
            float num = 0f;
            SpriteEffects effects = SpriteEffects.None;
            if (i == 1)
            {
                x = 0f;
                num = 0f - num + 2f;
                effects = SpriteEffects.FlipHorizontally;
            }
            Vector2 origin = rectangle.Size() * new Vector2(x, 0.5f);
            Vector2 vector = new Vector2(drawCenter.X + num, drawCenter.Y);
            if (rCurrentNPC.rotation != 0f)
            {
                vector = vector.RotatedBy(rCurrentNPC.rotation, rCurrentNPC.Bottom);
            }
            vector -= screenPos;
            float num2 = MathHelper.Clamp(rCurrentNPC.velocity.Y, -6f, 6f) * -0.1f;
            if (i == 0)
            {
                num2 *= -1f;
            }
            mySpriteBatch.Draw(value, vector, rectangle, originColor, rCurrentNPC.rotation + num2, origin, scale, effects, 0f);
        }
    }
 
    public void DrawNPCDirect(SpriteBatch mySpriteBatch, NPC rCurrentNPC, bool behindTiles, Vector2 screenPos)
    {
        int type = rCurrentNPC.type;
        rCurrentNPC.SetFrameSize();
        if (rCurrentNPC.realLife == -1 && rCurrentNPC.life >= rCurrentNPC.lifeMax && !rCurrentNPC.boss)
        {
            bool flag = Lighting.GetColor((int)((double)rCurrentNPC.position.X + (double)rCurrentNPC.width * 0.5) / 16, (int)(((double)rCurrentNPC.position.Y + (double)rCurrentNPC.height * 0.5) / 16.0)).ToVector3().Length() > 0.4325f;
            bool flag2 = false;
            if (LockOnHelper.AimedTarget == rCurrentNPC)
            {
                flag2 = true;
            }
            else if (rCurrentNPC.Distance(Main.player[myPlayer].Center) < 350f && flag)
            {
                flag2 = true;
            }
            if (flag2 && rCurrentNPC.lifeMax < 5)
            {
                flag2 = false;
            }
            if (flag2 && rCurrentNPC.aiStyle == 25 && rCurrentNPC.ai[0] == 0f)
            {
                flag2 = false;
            }
            if (flag2)
            {
                rCurrentNPC.nameOver = MathHelper.Clamp(rCurrentNPC.nameOver + 0.025f, 0f, 1f);
            }
            else
            {
                rCurrentNPC.nameOver = MathHelper.Clamp(rCurrentNPC.nameOver - 0.025f, 0f, 1f);
            }
        }
        else
        {
            rCurrentNPC.nameOver = MathHelper.Clamp(rCurrentNPC.nameOver - 0.025f, 0f, 1f);
        }
        if (type == 1 && rCurrentNPC.ai[0] == -999f)
        {
            return;
        }
        if (type == 101)
        {
            bool flag3 = true;
            Vector2 vector = new Vector2(rCurrentNPC.position.X + (float)(rCurrentNPC.width / 2), rCurrentNPC.position.Y + (float)(rCurrentNPC.height / 2));
            float num = rCurrentNPC.ai[0] * 16f + 8f - vector.X;
            float num2 = rCurrentNPC.ai[1] * 16f + 8f - vector.Y;
            float rotation = (float)Math.Atan2(num2, num) - 1.57f;
            bool flag4 = true;
            while (flag4)
            {
                float num3 = 0.75f;
                int height = 28;
                float num4 = (float)Math.Sqrt(num * num + num2 * num2);
                if (num4 < 28f * num3)
                {
                    height = (int)num4 - 40 + 28;
                    flag4 = false;
                }
                num4 = 20f * num3 / num4;
                num *= num4;
                num2 *= num4;
                vector.X += num;
                vector.Y += num2;
                num = rCurrentNPC.ai[0] * 16f + 8f - vector.X;
                num2 = rCurrentNPC.ai[1] * 16f + 8f - vector.Y;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f));
                if (rCurrentNPC.IsABestiaryIconDummy)
                {
                    color = rCurrentNPC.GetBestiaryEntryColor();
                }
                if (!flag3)
                {
                    flag3 = true;
                    mySpriteBatch.Draw(TextureAssets.Chain10.Value, new Vector2(vector.X - screenPos.X, vector.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain10.Width(), height), color, rotation, new Vector2((float)TextureAssets.Chain10.Width() * 0.5f, (float)TextureAssets.Chain10.Height() * 0.5f), num3, SpriteEffects.None, 0f);
                }
                else
                {
                    flag3 = false;
                    mySpriteBatch.Draw(TextureAssets.Chain11.Value, new Vector2(vector.X - screenPos.X, vector.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain10.Width(), height), color, rotation, new Vector2((float)TextureAssets.Chain10.Width() * 0.5f, (float)TextureAssets.Chain10.Height() * 0.5f), num3, SpriteEffects.None, 0f);
                }
            }
        }
        else if (rCurrentNPC.aiStyle == 13)
        {
            Vector2 vector2 = new Vector2(rCurrentNPC.position.X + (float)(rCurrentNPC.width / 2), rCurrentNPC.position.Y + (float)(rCurrentNPC.height / 2));
            float num5 = rCurrentNPC.ai[0] * 16f + 8f - vector2.X;
            float num6 = rCurrentNPC.ai[1] * 16f + 8f - vector2.Y;
            float rotation2 = (float)Math.Atan2(num6, num5) - 1.57f;
            bool flag5 = true;
            while (flag5)
            {
                int num7 = 28;
                int num8 = 40;
                if (type == 259 || type == 260)
                {
                    num8 = 20;
                    num7 = 12;
                }
                float num9 = (float)Math.Sqrt(num5 * num5 + num6 * num6);
                if (num9 < (float)num8)
                {
                    num7 = (int)num9 - num8 + num7;
                    flag5 = false;
                }
                num9 = (float)num7 / num9;
                num5 *= num9;
                num6 *= num9;
                vector2.X += num5;
                vector2.Y += num6;
                num5 = rCurrentNPC.ai[0] * 16f + 8f - vector2.X;
                num6 = rCurrentNPC.ai[1] * 16f + 8f - vector2.Y;
                Microsoft.Xna.Framework.Color color2 = Lighting.GetColor((int)vector2.X / 16, (int)(vector2.Y / 16f));
                if (rCurrentNPC.IsABestiaryIconDummy)
                {
                    color2 = rCurrentNPC.GetBestiaryEntryColor();
                }
                if (type == 259 || type == 260)
                {
                    color2.B = byte.MaxValue;
                    if (color2.R < 100)
                    {
                        color2.R = 100;
                    }
                    if (color2.G < 150)
                    {
                        color2.G = 150;
                    }
                }
                switch (type)
                {
                case 56:
                    mySpriteBatch.Draw(TextureAssets.Chain5.Value, new Vector2(vector2.X - screenPos.X, vector2.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain4.Width(), num7), color2, rotation2, new Vector2((float)TextureAssets.Chain4.Width() * 0.5f, (float)TextureAssets.Chain4.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                    break;
                case 175:
                    mySpriteBatch.Draw(TextureAssets.Chain14.Value, new Vector2(vector2.X - screenPos.X, vector2.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain14.Width(), num7), color2, rotation2, new Vector2((float)TextureAssets.Chain14.Width() * 0.5f, (float)TextureAssets.Chain14.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                    break;
                case 259:
                    mySpriteBatch.Draw(TextureAssets.Chain24.Value, new Vector2(vector2.X - screenPos.X, vector2.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain24.Width(), num7), color2, rotation2, new Vector2((float)TextureAssets.Chain24.Width() * 0.5f, (float)TextureAssets.Chain24.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                    break;
                case 260:
                    mySpriteBatch.Draw(TextureAssets.Chain25.Value, new Vector2(vector2.X - screenPos.X, vector2.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain25.Width(), num7), color2, rotation2, new Vector2((float)TextureAssets.Chain25.Width() * 0.5f, (float)TextureAssets.Chain25.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                    break;
                default:
                    mySpriteBatch.Draw(TextureAssets.Chain4.Value, new Vector2(vector2.X - screenPos.X, vector2.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain4.Width(), num7), color2, rotation2, new Vector2((float)TextureAssets.Chain4.Width() * 0.5f, (float)TextureAssets.Chain4.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                    break;
                }
            }
        }
        if (type == 327)
        {
            float rotation3 = 0f;
            Vector2 vector3 = new Vector2(rCurrentNPC.Center.X, rCurrentNPC.Center.Y + 80f);
            int num10 = (int)rCurrentNPC.localAI[1];
            Microsoft.Xna.Framework.Color color3 = Lighting.GetColor((int)vector3.X / 16, (int)(vector3.Y / 16f));
            mySpriteBatch.Draw(TextureAssets.PumpkingCloak.Value, new Vector2(vector3.X - screenPos.X, vector3.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.PumpkingCloak.Height() / 5 * num10, TextureAssets.PumpkingCloak.Width(), TextureAssets.PumpkingCloak.Height() / 5), color3, rotation3, new Vector2((float)TextureAssets.PumpkingCloak.Width() * 0.5f, (float)TextureAssets.PumpkingCloak.Height() * 0.5f / 5f), 1f, SpriteEffects.None, 0f);
        }
        if (type == 328)
        {
            Vector2 vector4 = new Vector2(rCurrentNPC.position.X + (float)rCurrentNPC.width * 0.5f - 5f * rCurrentNPC.ai[0], rCurrentNPC.position.Y + 20f);
            for (int i = 0; i < 2; i++)
            {
                float num11 = npc[(int)rCurrentNPC.ai[1]].position.X + (float)(npc[(int)rCurrentNPC.ai[1]].width / 2) - vector4.X;
                float num12 = npc[(int)rCurrentNPC.ai[1]].position.Y + (float)(npc[(int)rCurrentNPC.ai[1]].height / 2) - 30f - vector4.Y;
                float num13 = 0f;
                if (i == 0)
                {
                    num11 -= 200f * rCurrentNPC.ai[0];
                    num12 += 130f;
                    num13 = (float)Math.Sqrt(num11 * num11 + num12 * num12);
                    num13 = 92f / num13;
                    vector4.X += num11 * num13;
                    vector4.Y += num12 * num13;
                }
                else
                {
                    num11 -= 50f * rCurrentNPC.ai[0];
                    num12 += 80f;
                    num13 = (float)Math.Sqrt(num11 * num11 + num12 * num12);
                    num13 = 60f / num13;
                    vector4.X += num11 * num13;
                    vector4.Y += num12 * num13;
                }
                float rotation4 = (float)Math.Atan2(num12, num11) - 1.57f;
                Microsoft.Xna.Framework.Color color4 = Lighting.GetColor((int)vector4.X / 16, (int)(vector4.Y / 16f));
                mySpriteBatch.Draw(TextureAssets.PumpkingArm.Value, new Vector2(vector4.X - screenPos.X, vector4.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.PumpkingArm.Width(), TextureAssets.PumpkingArm.Height()), color4, rotation4, new Vector2((float)TextureAssets.PumpkingArm.Width() * 0.5f, (float)TextureAssets.PumpkingArm.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                if (i == 0)
                {
                    vector4.X += num11 * num13 / 2f;
                    vector4.Y += num12 * num13 / 2f;
                }
            }
        }
        if (type == 36)
        {
            Vector2 vector5 = new Vector2(rCurrentNPC.position.X + (float)rCurrentNPC.width * 0.5f - 5f * rCurrentNPC.ai[0], rCurrentNPC.position.Y + 20f);
            for (int j = 0; j < 2; j++)
            {
                float num14 = npc[(int)rCurrentNPC.ai[1]].position.X + (float)(npc[(int)rCurrentNPC.ai[1]].width / 2) - vector5.X;
                float num15 = npc[(int)rCurrentNPC.ai[1]].position.Y + (float)(npc[(int)rCurrentNPC.ai[1]].height / 2) - vector5.Y;
                float num16 = 0f;
                if (j == 0)
                {
                    num14 -= 200f * rCurrentNPC.ai[0];
                    num15 += 130f;
                    num16 = (float)Math.Sqrt(num14 * num14 + num15 * num15);
                    num16 = 92f / num16;
                    vector5.X += num14 * num16;
                    vector5.Y += num15 * num16;
                }
                else
                {
                    num14 -= 50f * rCurrentNPC.ai[0];
                    num15 += 80f;
                    num16 = (float)Math.Sqrt(num14 * num14 + num15 * num15);
                    num16 = 60f / num16;
                    vector5.X += num14 * num16;
                    vector5.Y += num15 * num16;
                }
                float rotation5 = (float)Math.Atan2(num15, num14) - 1.57f;
                Microsoft.Xna.Framework.Color color5 = Lighting.GetColor((int)vector5.X / 16, (int)(vector5.Y / 16f));
                mySpriteBatch.Draw(TextureAssets.BoneArm.Value, new Vector2(vector5.X - screenPos.X, vector5.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.BoneArm.Width(), TextureAssets.BoneArm.Height()), color5, rotation5, new Vector2((float)TextureAssets.BoneArm.Width() * 0.5f, (float)TextureAssets.BoneArm.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                if (j == 0)
                {
                    vector5.X += num14 * num16 / 2f;
                    vector5.Y += num15 * num16 / 2f;
                }
                else if (base.IsActive)
                {
                    vector5.X += num14 * num16 - 16f;
                    vector5.Y += num15 * num16 - 6f;
                    int num17 = Dust.NewDust(new Vector2(vector5.X, vector5.Y), 30, 10, 5, num14 * 0.02f, num15 * 0.02f, 0, default(Microsoft.Xna.Framework.Color), 2f);
                    dust[num17].noGravity = true;
                }
            }
        }
        if (rCurrentNPC.aiStyle == 47)
        {
            float scale = rCurrentNPC.scale;
            Vector2 vector6 = new Vector2(rCurrentNPC.Center.X, rCurrentNPC.Center.Y);
            Vector2 center = rCurrentNPC.Center;
            if (NPC.golemBoss != -1)
            {
                center = npc[NPC.golemBoss].Center;
            }
            float num18 = center.X - vector6.X;
            float num19 = center.Y - vector6.Y;
            num19 -= 7f * scale;
            num18 = ((type != 247) ? (num18 + 66f * scale) : (num18 - 70f * scale));
            float rotation6 = (float)Math.Atan2(num19, num18) - 1.57f;
            bool flag6 = true;
            while (flag6)
            {
                float num20 = (float)Math.Sqrt(num18 * num18 + num19 * num19);
                if (num20 < 16f)
                {
                    flag6 = false;
                    continue;
                }
                num20 = 16f * scale / num20;
                num18 *= num20;
                num19 *= num20;
                vector6.X += num18;
                vector6.Y += num19;
                num18 = center.X - vector6.X;
                num19 = center.Y - vector6.Y;
                num19 -= 7f * scale;
                num18 = ((type != 247) ? (num18 + 66f * scale) : (num18 - 70f * scale));
                if (getGoodWorld)
                {
                    num19 += 8f;
                }
                Microsoft.Xna.Framework.Color color6 = Lighting.GetColor((int)vector6.X / 16, (int)(vector6.Y / 16f));
                mySpriteBatch.Draw(TextureAssets.Chain21.Value, new Vector2(vector6.X - screenPos.X, vector6.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain21.Width(), TextureAssets.Chain21.Height()), color6, rotation6, new Vector2((float)TextureAssets.Chain21.Width() * 0.5f, (float)TextureAssets.Chain21.Height() * 0.5f), scale, SpriteEffects.None, 0f);
            }
        }
        if (rCurrentNPC.aiStyle >= 33 && rCurrentNPC.aiStyle <= 36)
        {
            Vector2 vector7 = new Vector2(rCurrentNPC.position.X + (float)rCurrentNPC.width * 0.5f - 5f * rCurrentNPC.ai[0], rCurrentNPC.position.Y + 20f);
            for (int k = 0; k < 2; k++)
            {
                float num21 = npc[(int)rCurrentNPC.ai[1]].position.X + (float)(npc[(int)rCurrentNPC.ai[1]].width / 2) - vector7.X;
                float num22 = npc[(int)rCurrentNPC.ai[1]].position.Y + (float)(npc[(int)rCurrentNPC.ai[1]].height / 2) - vector7.Y;
                float num23 = 0f;
                if (k == 0)
                {
                    num21 -= 200f * rCurrentNPC.ai[0];
                    num22 += 130f;
                    num23 = (float)Math.Sqrt(num21 * num21 + num22 * num22);
                    num23 = 92f / num23;
                    vector7.X += num21 * num23;
                    vector7.Y += num22 * num23;
                }
                else
                {
                    num21 -= 50f * rCurrentNPC.ai[0];
                    num22 += 80f;
                    num23 = (float)Math.Sqrt(num21 * num21 + num22 * num22);
                    num23 = 60f / num23;
                    vector7.X += num21 * num23;
                    vector7.Y += num22 * num23;
                }
                float rotation7 = (float)Math.Atan2(num22, num21) - 1.57f;
                Microsoft.Xna.Framework.Color color7 = Lighting.GetColor((int)vector7.X / 16, (int)(vector7.Y / 16f));
                mySpriteBatch.Draw(TextureAssets.BoneArm2.Value, new Vector2(vector7.X - screenPos.X, vector7.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.BoneArm.Width(), TextureAssets.BoneArm.Height()), color7, rotation7, new Vector2((float)TextureAssets.BoneArm.Width() * 0.5f, (float)TextureAssets.BoneArm.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
                if (k == 0)
                {
                    vector7.X += num21 * num23 / 2f;
                    vector7.Y += num22 * num23 / 2f;
                }
                else if (base.IsActive)
                {
                    vector7.X += num21 * num23 - 16f;
                    vector7.Y += num22 * num23 - 6f;
                    int num24 = Dust.NewDust(new Vector2(vector7.X, vector7.Y), 30, 10, 6, num21 * 0.02f, num22 * 0.02f, 0, default(Microsoft.Xna.Framework.Color), 2.5f);
                    dust[num24].noGravity = true;
                }
            }
        }
        if (rCurrentNPC.aiStyle == 20)
        {
            Vector2 vector8 = new Vector2(rCurrentNPC.position.X + (float)(rCurrentNPC.width / 2), rCurrentNPC.position.Y + (float)(rCurrentNPC.height / 2));
            float num25 = rCurrentNPC.ai[1] - vector8.X;
            float num26 = rCurrentNPC.ai[2] - vector8.Y;
            float num27 = (rCurrentNPC.rotation = (float)Math.Atan2(num26, num25) - 1.57f);
            bool flag7 = true;
            while (flag7)
            {
                int height2 = 12;
                float num28 = (float)Math.Sqrt(num25 * num25 + num26 * num26);
                if (num28 < 20f)
                {
                    height2 = (int)num28 - 20 + 12;
                    flag7 = false;
                }
                num28 = 12f / num28;
                num25 *= num28;
                num26 *= num28;
                vector8.X += num25;
                vector8.Y += num26;
                num25 = rCurrentNPC.ai[1] - vector8.X;
                num26 = rCurrentNPC.ai[2] - vector8.Y;
                Microsoft.Xna.Framework.Color color8 = Lighting.GetColor((int)vector8.X / 16, (int)(vector8.Y / 16f));
                mySpriteBatch.Draw(TextureAssets.Chain.Value, new Vector2(vector8.X - screenPos.X, vector8.Y - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain.Width(), height2), color8, num27, new Vector2((float)TextureAssets.Chain.Width() * 0.5f, (float)TextureAssets.Chain.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
            }
            mySpriteBatch.Draw(TextureAssets.SpikeBase.Value, new Vector2(rCurrentNPC.ai[1] - screenPos.X, rCurrentNPC.ai[2] - screenPos.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.SpikeBase.Width(), TextureAssets.SpikeBase.Height()), Lighting.GetColor((int)rCurrentNPC.ai[1] / 16, (int)(rCurrentNPC.ai[2] / 16f)), num27 - 0.75f, new Vector2((float)TextureAssets.SpikeBase.Width() * 0.5f, (float)TextureAssets.SpikeBase.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
        }
        Microsoft.Xna.Framework.Color npcColor = Lighting.GetColor((int)((double)rCurrentNPC.position.X + (double)rCurrentNPC.width * 0.5) / 16, (int)(((double)rCurrentNPC.position.Y + (double)rCurrentNPC.height * 0.5) / 16.0));
        if (rCurrentNPC.IsABestiaryIconDummy)
        {
            npcColor = rCurrentNPC.GetBestiaryEntryColor();
        }
        if (type >= 277 && type <= 280)
        {
            if (npcColor.R < byte.MaxValue)
            {
                npcColor.R = byte.MaxValue;
            }
            if (npcColor.G < 175)
            {
                npcColor.G = 175;
            }
        }
        if (type == -4)
        {
            int r = npcColor.R;
            int g = npcColor.G;
            int b = npcColor.B;
            r *= 2;
            if (r > 255)
            {
                r = 255;
            }
            g *= 2;
            if (g > 255)
            {
                g = 255;
            }
            b *= 2;
            if (b > 255)
            {
                b = 255;
            }
            npcColor = new Microsoft.Xna.Framework.Color(r, g, b);
        }
        if (behindTiles && type != 113 && type != 114)
        {
            int num29 = (int)((rCurrentNPC.position.X - 8f) / 16f);
            int num30 = (int)((rCurrentNPC.position.X + (float)rCurrentNPC.width + 8f) / 16f);
            int num31 = (int)((rCurrentNPC.position.Y - 8f) / 16f);
            int num32 = (int)((rCurrentNPC.position.Y + (float)rCurrentNPC.height + 8f) / 16f);
            for (int l = num29; l <= num30; l++)
            {
                for (int m = num31; m <= num32; m++)
                {
                    if (Lighting.Brightness(l, m) == 0f)
                    {
                        npcColor = Microsoft.Xna.Framework.Color.Black;
                    }
                }
            }
        }
        npcColor = rCurrentNPC.GetNPCColorTintedByBuffs(npcColor);
        if (type == 50)
        {
            Vector2 zero = Vector2.Zero;
            float num33 = 0f;
            zero.Y -= rCurrentNPC.velocity.Y;
            zero.X -= rCurrentNPC.velocity.X * 2f;
            num33 += rCurrentNPC.velocity.X * 0.05f;
            if (rCurrentNPC.frame.Y == 120)
            {
                zero.Y += 2f;
            }
            if (rCurrentNPC.frame.Y == 360)
            {
                zero.Y -= 2f;
            }
            if (rCurrentNPC.frame.Y == 480)
            {
                zero.Y -= 6f;
            }
            mySpriteBatch.Draw(TextureAssets.Ninja.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) + zero.X, rCurrentNPC.position.Y - screenPos.Y + (float)(rCurrentNPC.height / 2) + zero.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Ninja.Width(), TextureAssets.Ninja.Height()), npcColor, num33, new Vector2(TextureAssets.Ninja.Width() / 2, TextureAssets.Ninja.Height() / 2), 1f, SpriteEffects.None, 0f);
        }
        if (type == 71)
        {
            Vector2 zero2 = Vector2.Zero;
            float num34 = 0f;
            zero2.Y -= rCurrentNPC.velocity.Y * 0.3f;
            zero2.X -= rCurrentNPC.velocity.X * 0.6f;
            num34 += rCurrentNPC.velocity.X * 0.09f;
            if (rCurrentNPC.frame.Y == 120)
            {
                zero2.Y += 2f;
            }
            if (rCurrentNPC.frame.Y == 360)
            {
                zero2.Y -= 2f;
            }
            if (rCurrentNPC.frame.Y == 480)
            {
                zero2.Y -= 6f;
            }
            GetItemDrawFrame(327, out var itemTexture, out var rectangle);
            mySpriteBatch.Draw(itemTexture, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) + zero2.X, rCurrentNPC.position.Y - screenPos.Y + (float)(rCurrentNPC.height / 2) + zero2.Y), rectangle, npcColor, num34, rectangle.Size() / 2f, 1f, SpriteEffects.None, 0f);
        }
        if (type == 69)
        {
            mySpriteBatch.Draw(TextureAssets.AntLion.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2), rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height + 14f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.AntLion.Width(), TextureAssets.AntLion.Height()), npcColor, (0f - rCurrentNPC.rotation) * 0.3f, new Vector2(TextureAssets.AntLion.Width() / 2, TextureAssets.AntLion.Height() / 2), 1f, SpriteEffects.None, 0f);
        }
        if (type == 1 && rCurrentNPC.ai[1] > 0f)
        {
            DrawNPC_SlimeItem(rCurrentNPC, type, npcColor, 0f);
        }
        float num35 = 0f;
        float num36 = NPCAddHeight(rCurrentNPC);
        Vector2 halfSize = new Vector2(TextureAssets.Npc[type].Width() / 2, TextureAssets.Npc[type].Height() / npcFrameCount[type] / 2);
        if (type == 108 || type == 124 || type == 625)
        {
            num35 = 2f;
        }
        else if (type == 357)
        {
            num35 = rCurrentNPC.localAI[0];
        }
        else if (type == 467)
        {
            num35 = 7f;
        }
        else if (type == 537)
        {
            num35 = 2f;
        }
        else if (type == 581)
        {
            num35 = -6f;
        }
        else if (type == 490)
        {
            num35 = 4f;
        }
        else if (type == 484)
        {
            num35 = 2f;
        }
        else if (type == 483)
        {
            num35 = 14f;
        }
        else if (type == 477)
        {
            num36 = 22f;
        }
        else if (type == 478)
        {
            num35 -= 2f;
        }
        else if (type == 606)
        {
            num35 -= 2f;
        }
        else if (type == 612 || type == 613)
        {
            num35 -= 2f;
        }
        else if (type == 469 && rCurrentNPC.ai[2] == 1f)
        {
            num35 = 14f;
        }
        else
        {
            switch (type)
            {
            case 4:
                halfSize = new Vector2(55f, 107f);
                break;
            case 125:
                halfSize = new Vector2(55f, 107f);
                break;
            case 126:
                halfSize = new Vector2(55f, 107f);
                break;
            case 626:
            case 627:
                if (rCurrentNPC.wet)
                {
                    num35 = -2f;
                    halfSize = rCurrentNPC.frame.Size() * new Vector2(0.5f, 0.5f) + new Vector2(0f, -4f);
                }
                else
                {
                    num35 = 2f;
                }
                break;
            case 63:
            case 64:
            case 103:
                halfSize.Y += 4f;
                break;
            case 69:
                halfSize.Y += 8f;
                break;
            case 262:
                halfSize.Y = 77f;
                num36 += 26f;
                break;
            case 264:
                halfSize.Y = 21f;
                num36 += 2f;
                break;
            case 266:
                num36 += 50f * rCurrentNPC.scale;
                break;
            case 268:
                num36 += 16f;
                break;
            case 288:
                num36 += 6f;
                break;
            }
        }
        if (rCurrentNPC.aiStyle == 10 || type == 72)
        {
            npcColor = Microsoft.Xna.Framework.Color.White;
        }
        SpriteEffects spriteEffects = SpriteEffects.None;
        if (rCurrentNPC.spriteDirection == 1)
        {
            spriteEffects = SpriteEffects.FlipHorizontally;
        }
        if (type == 124 && rCurrentNPC.localAI[0] == 0f)
        {
            int num37 = 0;
            if (rCurrentNPC.frame.Y > 56)
            {
                num37 += 4;
            }
            num37 += rCurrentNPC.frame.Y / 56;
            if (num37 >= OffsetsPlayerHeadgear.Length)
            {
                num37 = 0;
            }
            float y = OffsetsPlayerHeadgear[num37].Y;
            LoadProjectile(582);
            Texture2D value = TextureAssets.Projectile[582].Value;
            if (rCurrentNPC.townNpcVariationIndex == 1)
            {
                value = TextureAssets.Extra[263].Value;
            }
            Vector2 position = rCurrentNPC.Center - screenPos;
            position -= new Vector2(value.Width, value.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
            position += new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY + y);
            position += new Vector2(-rCurrentNPC.spriteDirection * 2, -2f);
            mySpriteBatch.Draw(value, position, null, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, value.Size() * new Vector2(0f, 0.5f), rCurrentNPC.scale, spriteEffects, 0f);
        }
        switch (type)
        {
        default:
            if (type != 546 && type != 552 && type != 553 && type != 554 && type != 561 && type != 562 && type != 563 && type != 555 && type != 556 && type != 557 && type != 558 && type != 559 && type != 560 && type != 574 && type != 575 && type != 568 && type != 569 && type != 572 && type != 573 && type != 566 && type != 567 && type != 570 && type != 578 && type != 571 && type != 583 && type != 584 && type != 585 && type != 618 && type != 620 && type != 661)
            {
                switch (type)
                {
                case 551:
                {
                    Texture2D value2 = TextureAssets.Npc[type].Value;
                    Vector2 vector9 = rCurrentNPC.Center - screenPos;
                    Microsoft.Xna.Framework.Rectangle frame = rCurrentNPC.frame;
                    _ = frame.Size() / 2f;
                    SpriteEffects spriteEffects2 = spriteEffects ^ SpriteEffects.FlipHorizontally;
                    float rotation8 = rCurrentNPC.rotation;
                    Microsoft.Xna.Framework.Color color9 = npcColor;
                    Microsoft.Xna.Framework.Color color10 = Microsoft.Xna.Framework.Color.Lerp(color9, Microsoft.Xna.Framework.Color.White, 0.6f);
                    color10.A = 66;
                    Vector2 vector10 = new Vector2(171f, 44f);
                    Vector2 vector11 = new Vector2(230f, 52f);
                    Vector2 vector12 = Vector2.Lerp(vector10, vector11, 0.5f) + new Vector2(-50f, 30f);
                    int num38 = (int)rCurrentNPC.localAI[0] / 4;
                    Vector2 spinningpoint = vector10 - vector12;
                    Vector2 spinningpoint2 = vector11 - vector12;
                    Texture2D value3 = TextureAssets.Extra[82].Value;
                    if (spriteEffects2.HasFlag(SpriteEffects.FlipHorizontally))
                    {
                        spinningpoint2.X *= -1f;
                    }
                    Microsoft.Xna.Framework.Rectangle value4 = value3.Frame(2, 5, num38 / 5, num38 % 5);
                    Vector2 origin = new Vector2(16f, 176f);
                    if (spriteEffects2.HasFlag(SpriteEffects.FlipHorizontally))
                    {
                        origin.X = (float)value4.Width - origin.X;
                    }
                    if (spriteEffects2.HasFlag(SpriteEffects.FlipHorizontally))
                    {
                        vector12.X = (float)frame.Width - vector12.X;
                    }
                    Texture2D value5 = TextureAssets.Extra[81].Value;
                    if (spriteEffects2.HasFlag(SpriteEffects.FlipHorizontally))
                    {
                        spinningpoint.X *= -1f;
                    }
                    Microsoft.Xna.Framework.Rectangle value6 = value5.Frame(2, 5, num38 / 5, num38 % 5);
                    Vector2 origin2 = new Vector2(215f, 170f);
                    if (spriteEffects2.HasFlag(SpriteEffects.FlipHorizontally))
                    {
                        origin2.X = (float)value6.Width - origin2.X;
                    }
                    float lerpValue = Utils.GetLerpValue(0f, 30f, rCurrentNPC.localAI[1], clamped: true);
                    if (lerpValue == 1f)
                    {
                        lerpValue = Utils.GetLerpValue(60f, 30f, rCurrentNPC.localAI[1], clamped: true);
                    }
                    lerpValue = 2f;
                    Vector2 vector13 = rCurrentNPC.Size / 2f - screenPos;
                    int num39 = -3;
                    int num40 = 0;
                    byte b2 = 2;
                    for (int n = 9; n > num40; n += num39)
                    {
                        Vector2 vector14 = rCurrentNPC.oldPos[n] + vector13;
                        float num41 = rCurrentNPC.oldRot[n];
                        Microsoft.Xna.Framework.Color color11 = color9 * (1f - (float)n / 10f) * 0.35f;
                        color11.A /= b2;
                        mySpriteBatch.Draw(value3, vector14 + spinningpoint2.RotatedBy(num41), value4, color11, num41, origin, 1f, spriteEffects2, 0f);
                        mySpriteBatch.Draw(value2, vector14, frame, color11, num41, vector12, 1f, spriteEffects2, 0f);
                        mySpriteBatch.Draw(value5, vector14 + spinningpoint.RotatedBy(num41), value6, color11, num41, origin2, 1f, spriteEffects2, 0f);
                    }
                    mySpriteBatch.Draw(value3, vector9 + spinningpoint2.RotatedBy(rotation8), value4, color9, rotation8, origin, 1f, spriteEffects2, 0f);
                    mySpriteBatch.Draw(value2, vector9, frame, color9, rotation8, vector12, 1f, spriteEffects2, 0f);
                    mySpriteBatch.Draw(TextureAssets.GlowMask[226].Value, vector9, frame, color10 * (0.7f + 0.3f * lerpValue), rotation8, vector12, 1f, spriteEffects2, 0f);
                    mySpriteBatch.Draw(value5, vector9 + spinningpoint.RotatedBy(rotation8), value6, color9, rotation8, origin2, 1f, spriteEffects2, 0f);
                    return;
                }
                case 657:
                {
                    Texture2D value10 = TextureAssets.Npc[type].Value;
                    Vector2 position7 = rCurrentNPC.Bottom - screenPos;
                    position7.Y += 2f;
                    int num53 = npcFrameCount[rCurrentNPC.type];
                    int num54 = rCurrentNPC.frame.Y / rCurrentNPC.frame.Height;
                    Microsoft.Xna.Framework.Rectangle rectangle3 = value10.Frame(2, 16, num54 / num53, num54 % num53);
                    rectangle3.Inflate(0, -2);
                    Vector2 origin4 = rectangle3.Size() * new Vector2(0.5f, 1f);
                    Microsoft.Xna.Framework.Color color15 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.White, npcColor, 0.5f);
                    if (rCurrentNPC.life <= rCurrentNPC.lifeMax / 2)
                    {
                        DrawNPCDirect_QueenSlimeWings(rCurrentNPC, mySpriteBatch, screenPos, rCurrentNPC.Center, color15);
                    }
                    Texture2D value11 = TextureAssets.Extra[186].Value;
                    Microsoft.Xna.Framework.Rectangle rectangle4 = value11.Frame();
                    Vector2 origin5 = rectangle4.Size() * new Vector2(0.5f, 0.5f);
                    Vector2 vector16 = new Vector2(rCurrentNPC.Center.X, rCurrentNPC.Center.Y);
                    float num55 = 0f;
                    switch (num54)
                    {
                    case 1:
                    case 6:
                        num55 -= 10f;
                        break;
                    case 3:
                    case 5:
                        num55 += 10f;
                        break;
                    case 4:
                    case 12:
                    case 13:
                    case 14:
                    case 15:
                        num55 += 18f;
                        break;
                    case 7:
                    case 8:
                        num55 -= 14f;
                        break;
                    case 9:
                        num55 -= 16f;
                        break;
                    case 10:
                        num55 -= 18f;
                        break;
                    case 11:
                        num55 += 20f;
                        break;
                    case 20:
                        num55 -= 14f;
                        break;
                    case 21:
                    case 23:
                        num55 -= 18f;
                        break;
                    case 22:
                        num55 -= 22f;
                        break;
                    }
                    vector16.Y += num55;
                    if (rCurrentNPC.rotation != 0f)
                    {
                        vector16 = vector16.RotatedBy(rCurrentNPC.rotation, rCurrentNPC.Bottom);
                    }
                    vector16 -= screenPos;
                    if (!rCurrentNPC.IsABestiaryIconDummy)
                    {
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
                    }
                    GameShaders.Misc["QueenSlime"].Apply();
                    if (rCurrentNPC.ai[0] == 4f && rCurrentNPC.velocity.Y != 0f)
                    {
                        float num56 = 1f;
                        if (rCurrentNPC.ai[2] == 1f)
                        {
                            num56 = 6f;
                        }
                        for (int num57 = 7; num57 >= 0; num57--)
                        {
                            float num58 = 1f - (float)num57 / 8f;
                            Vector2 vector17 = rCurrentNPC.oldPos[num57] + new Vector2((float)rCurrentNPC.width * 0.5f, rCurrentNPC.height);
                            vector17 -= (rCurrentNPC.Bottom - Vector2.Lerp(vector17, rCurrentNPC.Bottom, 0.75f)) * num56;
                            vector17 -= screenPos;
                            Microsoft.Xna.Framework.Color color16 = color15 * num58;
                            mySpriteBatch.Draw(value10, vector17, rectangle3, color16, rCurrentNPC.rotation, origin4, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        }
                    }
                    if (!rCurrentNPC.IsABestiaryIconDummy)
                    {
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
                    }
                    pixelShader.CurrentTechnique.Passes[0].Apply();
                    mySpriteBatch.Draw(value11, vector16, rectangle4, color15, rCurrentNPC.rotation, origin5, 1f, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    GameShaders.Misc["QueenSlime"].Apply();
                    if (!rCurrentNPC.IsABestiaryIconDummy)
                    {
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
                    }
                    DrawData value12 = new DrawData(value10, position7, rectangle3, rCurrentNPC.GetAlpha(color15), rCurrentNPC.rotation, origin4, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally);
                    GameShaders.Misc["QueenSlime"].Apply(value12);
                    value12.Draw(mySpriteBatch);
                    pixelShader.CurrentTechnique.Passes[0].Apply();
                    if (!rCurrentNPC.IsABestiaryIconDummy)
                    {
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
                    }
                    Texture2D value13 = TextureAssets.Extra[177].Value;
                    rectangle3 = value13.Frame();
                    origin4 = rectangle3.Size() * new Vector2(0.5f, 0.5f);
                    position7 = new Vector2(rCurrentNPC.Center.X, rCurrentNPC.Top.Y - (float)rectangle3.Bottom + 44f);
                    float num59 = 0f;
                    switch (num54)
                    {
                    case 1:
                        num59 -= 10f;
                        break;
                    case 3:
                    case 5:
                    case 6:
                        num59 += 10f;
                        break;
                    case 4:
                    case 12:
                    case 13:
                    case 14:
                    case 15:
                        num59 += 18f;
                        break;
                    case 7:
                    case 8:
                        num59 -= 14f;
                        break;
                    case 9:
                        num59 -= 16f;
                        break;
                    case 10:
                        num59 -= 18f;
                        break;
                    case 11:
                        num59 += 20f;
                        break;
                    case 20:
                        num59 -= 14f;
                        break;
                    case 21:
                    case 23:
                        num59 -= 18f;
                        break;
                    case 22:
                        num59 -= 22f;
                        break;
                    }
                    position7.Y += num59;
                    if (rCurrentNPC.rotation != 0f)
                    {
                        position7 = position7.RotatedBy(rCurrentNPC.rotation, rCurrentNPC.Bottom);
                    }
                    position7 -= screenPos;
                    mySpriteBatch.Draw(value13, position7, rectangle3, color15, rCurrentNPC.rotation, origin4, 1f, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    return;
                }
                case 576:
                case 577:
                {
                    Texture2D value17 = TextureAssets.Npc[type].Value;
                    Vector2 vector18 = rCurrentNPC.Bottom - screenPos;
                    Microsoft.Xna.Framework.Rectangle rectangle7 = value17.Frame(5, 10, rCurrentNPC.frame.Y / 10, rCurrentNPC.frame.Y % 10);
                    Vector2 origin8 = rectangle7.Size() * new Vector2(0.5f, 1f);
                    origin8.Y -= 4f;
                    int num60 = 94;
                    if (rCurrentNPC.spriteDirection == 1)
                    {
                        origin8.X = num60;
                    }
                    else
                    {
                        origin8.X = rectangle7.Width - num60;
                    }
                    Microsoft.Xna.Framework.Color value18 = Microsoft.Xna.Framework.Color.White;
                    float amount3 = 0f;
                    float amount4 = 0f;
                    int num61 = 0;
                    float num62 = 0f;
                    Microsoft.Xna.Framework.Color color18 = npcColor;
                    if (rCurrentNPC.localAI[3] < 60f)
                    {
                        _ = 8f;
                        float num63 = rCurrentNPC.localAI[3] / 60f;
                        num61 = 3;
                        num62 = 1f - num63 * num63;
                        value18 = new Microsoft.Xna.Framework.Color(127, 0, 255, 0);
                        amount4 = 1f;
                        color18 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color18, num63 * num63);
                    }
                    for (int num64 = 0; num64 < num61; num64++)
                    {
                        Microsoft.Xna.Framework.Color value19 = npcColor;
                        value19 = Microsoft.Xna.Framework.Color.Lerp(value19, value18, amount3);
                        value19 = rCurrentNPC.GetAlpha(value19);
                        value19 = Microsoft.Xna.Framework.Color.Lerp(value19, value18, amount4);
                        value19 *= 1f - num62;
                        Vector2 position10 = vector18;
                        position10 -= new Vector2(value17.Width, value17.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position10 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value17, position10, rectangle7, value19, rCurrentNPC.rotation, origin8, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    mySpriteBatch.Draw(value17, vector18, rectangle7, rCurrentNPC.GetAlpha(color18), rCurrentNPC.rotation, origin8, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    return;
                }
                case 594:
                {
                    Texture2D value14 = TextureAssets.Npc[type].Value;
                    Vector2 position8 = rCurrentNPC.Top - screenPos;
                    Microsoft.Xna.Framework.Rectangle rectangle5 = value14.Frame(8, 1, rCurrentNPC.frame.Y);
                    Microsoft.Xna.Framework.Rectangle value15 = value14.Frame(8);
                    Vector2 origin6 = rectangle5.Size() * new Vector2(0.5f, 0f);
                    Microsoft.Xna.Framework.Color color17 = npcColor;
                    float scale3 = 1f;
                    NPC nPC = rCurrentNPC.AI_113_WindyBalloon_GetSlaveNPC();
                    if (nPC != null)
                    {
                        scale3 = nPC.scale;
                        if (nPC.ai[1] > 0f)
                        {
                            DrawNPC_SlimeItem(nPC, nPC.type, color17, rCurrentNPC.rotation);
                        }
                        mySpriteBatch.Draw(value14, position8, value15, nPC.GetAlpha(color17), rCurrentNPC.rotation, origin6, scale3, spriteEffects, 0f);
                        mySpriteBatch.Draw(value14, position8, value15, nPC.GetColor(color17), rCurrentNPC.rotation, origin6, scale3, spriteEffects, 0f);
                    }
                    mySpriteBatch.Draw(value14, position8, rectangle5, rCurrentNPC.GetAlpha(color17), rCurrentNPC.rotation, origin6, scale3, spriteEffects, 0f);
                    return;
                }
                case 686:
                {
                    Texture2D value16 = TextureAssets.Npc[type].Value;
                    Vector2 position9 = rCurrentNPC.Top - screenPos;
                    Microsoft.Xna.Framework.Rectangle rectangle6 = value16.Frame();
                    Vector2 origin7 = rectangle6.Size() * new Vector2(0.5f, 0f);
                    Microsoft.Xna.Framework.Color newColor2 = npcColor;
                    mySpriteBatch.Draw(value16, position9, rectangle6, rCurrentNPC.GetAlpha(newColor2), rCurrentNPC.rotation, origin7, rCurrentNPC.scale, spriteEffects, 0f);
                    return;
                }
                case 564:
                case 565:
                {
                    Texture2D value20 = TextureAssets.Npc[type].Value;
                    Vector2 vector19 = rCurrentNPC.Bottom - screenPos;
                    Microsoft.Xna.Framework.Rectangle rectangle8 = value20.Frame(5, 9, rCurrentNPC.frame.Y / 9, rCurrentNPC.frame.Y % 9);
                    Vector2 origin9 = rectangle8.Size() * new Vector2(0.5f, 1f);
                    origin9.Y -= 10f;
                    int num65 = 52;
                    if (rCurrentNPC.spriteDirection == 1)
                    {
                        origin9.X = num65;
                    }
                    else
                    {
                        origin9.X = rectangle8.Width - num65;
                    }
                    Microsoft.Xna.Framework.Color value21 = Microsoft.Xna.Framework.Color.White;
                    float amount5 = 0f;
                    float amount6 = 0f;
                    int num66 = 0;
                    float num67 = 0f;
                    float num68 = 0f;
                    Microsoft.Xna.Framework.Color color19 = npcColor;
                    if (rCurrentNPC.localAI[3] < 60f)
                    {
                        float num69 = rCurrentNPC.localAI[3] / 60f;
                        num66 = 3;
                        num67 = 1f - num69 * num69;
                        num68 = 8f;
                        value21 = new Microsoft.Xna.Framework.Color(127, 0, 255, 0);
                        amount6 = 1f;
                        color19 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color19, num69 * num69);
                    }
                    for (int num70 = 0; num70 < num66; num70++)
                    {
                        Microsoft.Xna.Framework.Color value22 = npcColor;
                        value22 = Microsoft.Xna.Framework.Color.Lerp(value22, value21, amount5);
                        value22 = rCurrentNPC.GetAlpha(value22);
                        value22 = Microsoft.Xna.Framework.Color.Lerp(value22, value21, amount6);
                        value22 *= 1f - num67;
                        Vector2 position11 = vector19;
                        position11 -= new Vector2(value20.Width, value20.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position11 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        position11 += ((float)num70 / (float)num66 * ((float)Math.PI * 2f)).ToRotationVector2() * num68 * num67;
                        mySpriteBatch.Draw(value20, position11, rectangle8, value22, rCurrentNPC.rotation, origin9, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    Microsoft.Xna.Framework.Color alpha2 = rCurrentNPC.GetAlpha(color19);
                    num66 = 4;
                    num68 = 4f;
                    num67 = 0.625f + (float)Math.Sin(GlobalTimeWrappedHourly * ((float)Math.PI * 2f) * 0.75f + (float)Math.PI) * 0.125f;
                    for (int num71 = 0; num71 < num66; num71++)
                    {
                        Microsoft.Xna.Framework.Color color20 = alpha2;
                        color20 *= 1f - num67;
                        Vector2 position12 = vector19;
                        position12 -= new Vector2(value20.Width, value20.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position12 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        position12 += ((float)num71 / (float)num66 * ((float)Math.PI * 2f)).ToRotationVector2() * num68 * num67;
                        mySpriteBatch.Draw(value20, position12, rectangle8, color20, rCurrentNPC.rotation, origin9, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    mySpriteBatch.Draw(value20, vector19, rectangle8, alpha2, rCurrentNPC.rotation, origin9, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    if (rCurrentNPC.Opacity > 0f)
                    {
                        Microsoft.Xna.Framework.Color white2 = Microsoft.Xna.Framework.Color.White;
                        white2.A /= 2;
                        white2 *= rCurrentNPC.Opacity;
                        mySpriteBatch.Draw(TextureAssets.GlowMask[225].Value, vector19, rectangle8, white2, rCurrentNPC.rotation, origin9, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        num66 = 4;
                        num68 = 4f;
                        num67 = 0.5f + (float)Math.Sin(GlobalTimeWrappedHourly * ((float)Math.PI * 2f) * 0.75f) * 0.5f;
                        for (int num72 = 0; num72 < num66; num72++)
                        {
                            Microsoft.Xna.Framework.Color color21 = white2 * 0.35f;
                            color21 *= 1f - num67;
                            Vector2 position13 = vector19;
                            position13 -= new Vector2(value20.Width, value20.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                            position13 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                            position13 += ((float)num72 / (float)num66 * ((float)Math.PI * 2f)).ToRotationVector2() * num68 * num67;
                            mySpriteBatch.Draw(TextureAssets.GlowMask[225].Value, position13, rectangle8, color21, rCurrentNPC.rotation, origin9, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        }
                    }
                    return;
                }
                case 548:
                {
                    Texture2D value8 = TextureAssets.Npc[type].Value;
                    Vector2 vector15 = rCurrentNPC.Bottom - screenPos;
                    Microsoft.Xna.Framework.Rectangle rectangle2 = value8.Frame();
                    Vector2 origin3 = rectangle2.Size() / 2f;
                    origin3.Y += 30f;
                    origin3.Y += 8f;
                    origin3.X -= 1f;
                    Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
                    float amount = 0f;
                    float amount2 = 0f;
                    int num42 = 0;
                    float num43 = 0f;
                    float num44 = 0f;
                    Microsoft.Xna.Framework.Color newColor = npcColor;
                    for (int num45 = 0; num45 < num42; num45++)
                    {
                        Microsoft.Xna.Framework.Color value9 = npcColor;
                        value9 = Microsoft.Xna.Framework.Color.Lerp(value9, white, amount);
                        value9 = rCurrentNPC.GetAlpha(value9);
                        value9 = Microsoft.Xna.Framework.Color.Lerp(value9, white, amount2);
                        value9 *= 1f - num43;
                        Vector2 position3 = vector15;
                        position3 -= new Vector2(value8.Width, value8.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position3 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        position3 += ((float)num45 / (float)num42 * ((float)Math.PI * 2f)).ToRotationVector2() * num44 * num43;
                        mySpriteBatch.Draw(value8, position3, rectangle2, value9, rCurrentNPC.rotation, origin3, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    Microsoft.Xna.Framework.Color alpha = rCurrentNPC.GetAlpha(newColor);
                    num42 = 4;
                    num44 = 4f;
                    num43 = 0.625f + (float)Math.Sin(GlobalTimeWrappedHourly * ((float)Math.PI * 2f) * 0.75f + (float)Math.PI) * 0.125f;
                    for (int num46 = 0; num46 < num42; num46++)
                    {
                        Microsoft.Xna.Framework.Color color12 = alpha;
                        color12.A = 0;
                        color12 *= 1f - num43;
                        Vector2 position4 = vector15;
                        position4 -= new Vector2(value8.Width, value8.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position4 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        position4 += ((float)num46 / (float)num42 * ((float)Math.PI * 2f)).ToRotationVector2() * num44 * num43;
                        mySpriteBatch.Draw(value8, position4, rectangle2, color12, rCurrentNPC.rotation, origin3, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    mySpriteBatch.Draw(value8, vector15, rectangle2, alpha, rCurrentNPC.rotation, origin3, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    if (rCurrentNPC.ai[1] == 2f)
                    {
                        float num47 = Math.Min(1f, rCurrentNPC.ai[0] / 120f);
                        mySpriteBatch.Draw(value8, vector15, rectangle2, new Microsoft.Xna.Framework.Color(1f, 1f, 1f, 0f) * num47, rCurrentNPC.rotation, origin3, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        float progress = MathHelper.Clamp(rCurrentNPC.ai[0] / 450f, 0f, 1f);
                        if (!Terraria.Graphics.Effects.Filters.Scene["CrystalWin"].IsActive())
                        {
                            Terraria.Graphics.Effects.Filters.Scene.Activate("CrystalWin", rCurrentNPC.Center);
                        }
                        else
                        {
                            Terraria.Graphics.Effects.Filters.Scene["CrystalWin"].GetShader().UseProgress(progress);
                        }
                        Terraria.Graphics.Effects.Filters.Scene["CrystalWin"].GetShader().UseTargetPosition(rCurrentNPC.Center);
                    }
                    num42 = 4;
                    num44 = 4f;
                    num43 = 0.625f + (float)Math.Sin(GlobalTimeWrappedHourly * ((float)Math.PI * 2f) * 0.75f) * 0.125f;
                    for (int num48 = 0; num48 < num42; num48++)
                    {
                        Microsoft.Xna.Framework.Color color13 = alpha;
                        color13.A = 0;
                        color13 *= 0.3f;
                        color13 *= 1f - num43;
                        Vector2 position5 = vector15;
                        position5 -= new Vector2(value8.Width, value8.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position5 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        position5 += ((float)num48 / (float)num42 * ((float)Math.PI * 2f)).ToRotationVector2() * num44 * num43;
                        mySpriteBatch.Draw(value8, position5, rectangle2, color13, rCurrentNPC.rotation, origin3, rCurrentNPC.scale, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    if (rCurrentNPC.alpha < 255)
                    {
                        float num49 = GlobalTimeWrappedHourly % 3f / 3f;
                        float num50 = num49;
                        if (num50 > 0.5f)
                        {
                            num50 = 1f - num49;
                        }
                        if (num50 < 0f)
                        {
                            num50 = 0f;
                        }
                        float num51 = (num49 + 0.5f) % 1f;
                        float num52 = num51;
                        if (num52 > 0.5f)
                        {
                            num52 = 1f - num51;
                        }
                        if (num52 < 0f)
                        {
                            num52 = 0f;
                        }
                        value8 = TextureAssets.GlowMask[239].Value;
                        rectangle2 = value8.Frame();
                        origin3 = rectangle2.Size() / 2f;
                        Vector2 position6 = vector15 + new Vector2(0f, -40f);
                        Microsoft.Xna.Framework.Color color14 = new Microsoft.Xna.Framework.Color(140, 50, 255, 0);
                        color14 *= 0.6f;
                        mySpriteBatch.Draw(value8, position6, rectangle2, color14, rCurrentNPC.rotation, origin3, rCurrentNPC.scale * 0.75f, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        num43 = 1f + num49 * 0.75f;
                        mySpriteBatch.Draw(value8, position6, rectangle2, color14 * num50, rCurrentNPC.rotation, origin3, rCurrentNPC.scale * 0.75f * num43, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        num43 = 1f + num51 * 0.75f;
                        mySpriteBatch.Draw(value8, position6, rectangle2, color14 * num52, rCurrentNPC.rotation, origin3, rCurrentNPC.scale * 0.75f * num43, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        value8 = TextureAssets.Extra[89].Value;
                        rectangle2 = value8.Frame();
                        origin3 = rectangle2.Size() / 2f;
                        Vector2 scale2 = new Vector2(0.75f, 1f + num43) * 1.5f;
                        num43 = 1f + num51 * 0.75f;
                        if (rCurrentNPC.dontTakeDamageFromHostiles)
                        {
                            scale2.Y *= 0.6f;
                        }
                        position6.Y -= 6f;
                        mySpriteBatch.Draw(value8, position6, rectangle2, color14 * num52, rCurrentNPC.rotation + (float)Math.PI / 2f, origin3, scale2, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                        mySpriteBatch.Draw(value8, position6, rectangle2, Microsoft.Xna.Framework.Color.Lerp(color14, Microsoft.Xna.Framework.Color.White, 0.5f), rCurrentNPC.rotation + (float)Math.PI / 2f, origin3, 1.5f, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
                    }
                    return;
                }
                default:
                    if (type < 621 || type > 623)
                    {
                        break;
                    }
                    goto case 371;
                case 371:
                case 454:
                case 455:
                case 456:
                case 457:
                case 458:
                case 459:
                {
                    Texture2D value7 = TextureAssets.Npc[type].Value;
                    Vector2 position2 = rCurrentNPC.Center - screenPos;
                    position2 -= new Vector2(value7.Width, value7.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    position2 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(value7, position2, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    return;
                }
                }
                switch (type)
                {
                case 549:
                {
                    Texture2D value58 = TextureAssets.Npc[type].Value;
                    Vector2 vector61 = rCurrentNPC.Center - screenPos;
                    Microsoft.Xna.Framework.Rectangle frame9 = rCurrentNPC.frame;
                    Vector2 origin22 = new Vector2(70f, 127f);
                    origin22.Y += 8f;
                    Vector2 scale6 = new Vector2(rCurrentNPC.scale);
                    float num201 = rCurrentNPC.localAI[0];
                    if (num201 < 120f)
                    {
                        scale6 *= num201 / 240f + 0.5f;
                    }
                    Microsoft.Xna.Framework.Color alpha12 = rCurrentNPC.GetAlpha(npcColor);
                    float lerpValue2 = Utils.GetLerpValue(0f, 120f, num201, clamped: true);
                    float num202 = MathHelper.Lerp(32f, 0f, lerpValue2);
                    Microsoft.Xna.Framework.Color color42 = alpha12;
                    color42.A = (byte)MathHelper.Lerp((int)color42.A, 0f, lerpValue2);
                    color42 *= lerpValue2;
                    if (num201 >= 120f)
                    {
                        color42 = alpha12;
                    }
                    mySpriteBatch.Draw(value58, vector61, frame9, color42, rCurrentNPC.rotation, origin22, scale6, spriteEffects, 0f);
                    float y3 = (((rCurrentNPC.ai[0] + 54f) % 180f - 120f) / 180f * 2f * ((float)Math.PI * 2f)).ToRotationVector2().Y;
                    if (num201 >= 120f)
                    {
                        num202 = y3 * 0f;
                        color42.A = (byte)((float)(int)color42.A * 0.5f);
                        color42 *= y3 / 2f + 0.5f;
                        float num203 = 1f;
                        for (float num204 = 0f; num204 < num203; num204 += 1f)
                        {
                            mySpriteBatch.Draw(value58, vector61 + ((float)Math.PI * 2f / num203 * num204).ToRotationVector2() * num202, frame9, color42, rCurrentNPC.rotation, origin22, scale6, spriteEffects, 0f);
                        }
                    }
                    float num205 = rCurrentNPC.ai[0] / 180f - 0.76f;
                    if (num205 < 0f)
                    {
                        num205 += 1f;
                    }
                    float num206 = 0f;
                    float num207 = 0f;
                    float num208 = 0.6f;
                    float num209 = 0.8f;
                    if (num205 >= num208 && num205 <= num209)
                    {
                        num206 = Utils.GetLerpValue(num208, num209, num205);
                        num207 = MathHelper.Lerp(0.75f, 0.85f, num206);
                    }
                    num208 = num209;
                    num209 = num208 + 0.13f;
                    if (num205 >= num208 && num205 <= num209)
                    {
                        num206 = 1f - Utils.GetLerpValue(num208, num209, num205);
                        num207 = MathHelper.Lerp(1.3f, 0.85f, num206);
                    }
                    Vector2 vector62 = new Vector2(0f, -150f);
                    int frameNumber = frame9.Y / frame9.Height;
                    float num210 = MathHelper.Clamp((num201 - 100f) / 40f, 0f, 1f);
                    DrawElderEye(mySpriteBatch, rCurrentNPC.Center + vector62, 0.75f * num210, 0.75f, frameNumber, Microsoft.Xna.Framework.Color.White);
                    DrawElderEye(mySpriteBatch, rCurrentNPC.Center + vector62, 0.75f * num210, 0.75f, frameNumber, new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * (y3 / 2f + 0.5f));
                    if (num206 > 0f && num207 > 0f)
                    {
                        DrawElderEye(mySpriteBatch, rCurrentNPC.Center + vector62, num206 * 0.5f, num207, frameNumber, new Microsoft.Xna.Framework.Color(255, 255, 255, 127));
                    }
                    if (num201 < 120f)
                    {
                        float num211 = (float)Math.PI * 2f * lerpValue2 * (float)Math.Pow(lerpValue2, 2.0) * 2f + lerpValue2;
                        color42.A = (byte)((float)(int)alpha12.A * (float)Math.Pow(lerpValue2, 2.0) * 0.5f);
                        float num212 = 3f;
                        for (float num213 = 0f; num213 < num212; num213 += 1f)
                        {
                            mySpriteBatch.Draw(value58, vector61 + (num211 + (float)Math.PI * 2f / num212 * num213).ToRotationVector2() * num202, frame9, color42, rCurrentNPC.rotation, origin22, scale6, spriteEffects, 0f);
                        }
                    }
                    break;
                }
                case 636:
                    DrawNPCDirect_HallowBoss(mySpriteBatch, rCurrentNPC, ref screenPos, type, ref npcColor, ref halfSize, spriteEffects);
                    break;
                case 677:
                    DrawNPCDirect_Faeling(mySpriteBatch, rCurrentNPC, ref screenPos, type, ref npcColor, ref halfSize, spriteEffects);
                    break;
                case 668:
                    DrawNPCDirect_Deerclops(mySpriteBatch, rCurrentNPC, ref screenPos, type, ref npcColor, ref halfSize, spriteEffects);
                    break;
                case 422:
                case 493:
                case 507:
                case 517:
                {
                    Texture2D value60 = TextureAssets.Npc[type].Value;
                    Vector2 vector65 = rCurrentNPC.Center - screenPos;
                    Vector2 vector66 = vector65 - new Vector2(300f, 310f);
                    vector65 -= new Vector2(value60.Width, value60.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    vector65 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(value60, vector65, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    switch (type)
                    {
                    case 493:
                    {
                        value60 = TextureAssets.GlowMask[132].Value;
                        float num228 = 4f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 4f;
                        for (int num229 = 0; num229 < 4; num229++)
                        {
                            mySpriteBatch.Draw(value60, vector65 + rCurrentNPC.velocity.RotatedBy((float)num229 * ((float)Math.PI / 2f)) * num228, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0) * rCurrentNPC.Opacity, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    case 507:
                    {
                        value60 = TextureAssets.GlowMask[143].Value;
                        float num224 = 4f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 4f;
                        for (int num225 = 0; num225 < 4; num225++)
                        {
                            mySpriteBatch.Draw(value60, vector65 + rCurrentNPC.velocity.RotatedBy((float)num225 * ((float)Math.PI / 2f)) * num224, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0) * rCurrentNPC.Opacity, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    case 422:
                    {
                        value60 = TextureAssets.GlowMask[149].Value;
                        float num226 = 4f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 4f;
                        for (int num227 = 0; num227 < 4; num227++)
                        {
                            mySpriteBatch.Draw(value60, vector65 + rCurrentNPC.velocity.RotatedBy((float)num227 * ((float)Math.PI / 2f)) * num226, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0) * rCurrentNPC.Opacity, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    case 517:
                    {
                        value60 = TextureAssets.GlowMask[162].Value;
                        float num222 = 2f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 9f;
                        for (int num223 = 0; num223 < 4; num223++)
                        {
                            mySpriteBatch.Draw(value60, vector65 + rCurrentNPC.velocity.RotatedBy((float)num223 * ((float)Math.PI / 2f)) * num222 + Vector2.UnitX * 2f, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0) * rCurrentNPC.Opacity, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    }
                    int num230 = 0;
                    string key = "";
                    switch (type)
                    {
                    case 422:
                        num230 = NPC.ShieldStrengthTowerVortex;
                        key = "Vortex";
                        break;
                    case 507:
                        num230 = NPC.ShieldStrengthTowerNebula;
                        key = "Nebula";
                        break;
                    case 517:
                        num230 = NPC.ShieldStrengthTowerSolar;
                        key = "Solar";
                        break;
                    case 493:
                        num230 = NPC.ShieldStrengthTowerStardust;
                        key = "Stardust";
                        break;
                    }
                    float num231 = (float)num230 / (float)NPC.ShieldStrengthTowerMax;
                    if (rCurrentNPC.IsABestiaryIconDummy)
                    {
                        break;
                    }
                    if (num230 > 0)
                    {
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointWrap, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
                        float num232 = 0f;
                        if (rCurrentNPC.ai[3] > 0f && rCurrentNPC.ai[3] <= 30f)
                        {
                            num232 = 1f - rCurrentNPC.ai[3] / 30f;
                        }
                        Terraria.Graphics.Effects.Filters.Scene[key].GetShader().UseIntensity(1f + num232).UseProgress(0f);
                        DrawData value61 = new DrawData(Assets.Request<Texture2D>("Images/Misc/Perlin", (AssetRequestMode)1).Value, vector66 + new Vector2(300f, 300f), new Microsoft.Xna.Framework.Rectangle(0, 0, 600, 600), Microsoft.Xna.Framework.Color.White * (num231 * 0.8f + 0.2f), rCurrentNPC.rotation, new Vector2(300f, 300f), rCurrentNPC.scale * (1f + num232 * 0.05f), spriteEffects);
                        GameShaders.Misc["ForceField"].UseColor(new Vector3(1f + num232 * 0.5f));
                        GameShaders.Misc["ForceField"].Apply(value61);
                        value61.Draw(mySpriteBatch);
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
                    }
                    else if (rCurrentNPC.ai[3] > 0f)
                    {
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointWrap, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
                        float num233 = rCurrentNPC.ai[3] / 120f;
                        float num234 = Math.Min(rCurrentNPC.ai[3] / 30f, 1f);
                        Terraria.Graphics.Effects.Filters.Scene[key].GetShader().UseIntensity(Math.Min(5f, 15f * num233) + 1f).UseProgress(num233);
                        DrawData value62 = new DrawData(Assets.Request<Texture2D>("Images/Misc/Perlin", (AssetRequestMode)1).Value, vector66 + new Vector2(300f, 300f), new Microsoft.Xna.Framework.Rectangle(0, 0, 600, 600), new Microsoft.Xna.Framework.Color(new Vector4(1f - (float)Math.Sqrt(num234))), rCurrentNPC.rotation, new Vector2(300f, 300f), rCurrentNPC.scale * (1f + num234), spriteEffects);
                        GameShaders.Misc["ForceField"].UseColor(new Vector3(2f));
                        GameShaders.Misc["ForceField"].Apply(value62);
                        value62.Draw(mySpriteBatch);
                        mySpriteBatch.End();
                        mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
                    }
                    else
                    {
                        Terraria.Graphics.Effects.Filters.Scene[key].GetShader().UseIntensity(0f).UseProgress(0f);
                    }
                    break;
                }
                case 402:
                {
                    LoadNPC(403);
                    LoadNPC(404);
                    Texture2D value59 = TextureAssets.Npc[rCurrentNPC.type].Value;
                    Vector2 vector63 = rCurrentNPC.Center - screenPos;
                    vector63 -= new Vector2(value59.Width, value59.Height / npcFrameCount[rCurrentNPC.type]) * rCurrentNPC.scale / 2f;
                    vector63 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    int num214 = 0;
                    float num215 = 2f / (float)rCurrentNPC.oldPos.Length * 0.7f;
                    float num216 = 600f;
                    float num217 = num216 - 30f;
                    float num218 = Utils.Remap(rCurrentNPC.ai[2], 0f, num216, 0f, 1f);
                    float num219 = 1f - Utils.Remap(num218, 0.5f, num217 / num216, 0f, 1f) * Utils.Remap(num218, num217 / num216, 1f, 1f, 0f);
                    int num220 = rCurrentNPC.oldPos.Length - 1;
                    while ((float)num220 >= 1f)
                    {
                        for (int num221 = 0; num221 < 2; num221++)
                        {
                            value59 = ((num214 != 0) ? TextureAssets.Npc[403].Value : TextureAssets.Npc[404].Value);
                            Vector2 position21 = vector63 + rCurrentNPC.oldPos[num220] - rCurrentNPC.position;
                            float rotation10 = rCurrentNPC.oldRot[num220];
                            if (num220 >= 1 && num221 == 1)
                            {
                                Vector2 vector64 = Vector2.Lerp(rCurrentNPC.oldPos[num220], rCurrentNPC.oldPos[num220 - 1], 0.5f) - rCurrentNPC.oldPos[num220];
                                rotation10 = MathHelper.WrapAngle(rCurrentNPC.oldRot[num220 - 1] * 0.5f + rCurrentNPC.oldRot[num220] * 0.5f);
                                position21 += vector64;
                            }
                            float scale7 = rCurrentNPC.scale;
                            mySpriteBatch.Draw(value59, position21, null, rCurrentNPC.GetAlpha(npcColor) * (0.8f - num215 * (float)num220 / 2f) * num219, rotation10, halfSize, scale7, spriteEffects, 0f);
                            value59 = ((num214 != 0) ? TextureAssets.GlowMask[133].Value : TextureAssets.GlowMask[134].Value);
                            mySpriteBatch.Draw(value59, position21, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * (1f - num215 * (float)num220 / 2f) * num219, rotation10, halfSize, scale7, spriteEffects, 0f);
                            num214++;
                        }
                        num220 -= 2;
                    }
                    value59 = TextureAssets.Npc[rCurrentNPC.type].Value;
                    mySpriteBatch.Draw(value59, vector63, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    value59 = TextureAssets.GlowMask[135].Value;
                    mySpriteBatch.Draw(value59, vector63, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num219, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    DrawPrettyStarSparkle(Utils.Remap(rCurrentNPC.ai[2], 0f, num216, 0f, 1f), SpriteEffects.None, vector63, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), Microsoft.Xna.Framework.Color.CornflowerBlue, num218, 0.5f, num217 / num216, num217 / num216, 1f, (float)Math.PI * 2f * num218, new Vector2(2f, 2f), new Vector2(2f, 2f));
                    break;
                }
                case 519:
                {
                    Texture2D value63 = TextureAssets.Npc[rCurrentNPC.type].Value;
                    Vector2 vector67 = rCurrentNPC.Center - screenPos;
                    vector67 -= new Vector2(value63.Width, value63.Height / npcFrameCount[rCurrentNPC.type]) * rCurrentNPC.scale / 2f;
                    vector67 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    value63 = TextureAssets.Npc[rCurrentNPC.type].Value;
                    mySpriteBatch.Draw(value63, vector67, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    int num235 = 0;
                    float num236 = 1f / (float)rCurrentNPC.oldPos.Length * 0.7f;
                    int num237 = rCurrentNPC.oldPos.Length - 1;
                    while ((float)num237 >= 0f)
                    {
                        float num238 = (float)(rCurrentNPC.oldPos.Length - num237) / (float)rCurrentNPC.oldPos.Length;
                        Microsoft.Xna.Framework.Color pink = Microsoft.Xna.Framework.Color.Pink;
                        pink *= 1f - num236 * (float)num237 / 1f;
                        pink.A = (byte)((float)(int)pink.A * (1f - num238));
                        mySpriteBatch.Draw(value63, vector67 + rCurrentNPC.oldPos[num237] - rCurrentNPC.position, null, pink, rCurrentNPC.oldRot[num237], halfSize, rCurrentNPC.scale * MathHelper.Lerp(0.3f, 1.1f, num238), spriteEffects, 0f);
                        num235++;
                        num237--;
                    }
                    break;
                }
                case 522:
                {
                    Texture2D value70 = TextureAssets.Npc[rCurrentNPC.type].Value;
                    Vector2 vector68 = rCurrentNPC.Center - screenPos;
                    vector68 -= new Vector2(value70.Width, value70.Height / npcFrameCount[rCurrentNPC.type]) * rCurrentNPC.scale / 2f;
                    vector68 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    int num256 = 0;
                    float num257 = 1f / (float)rCurrentNPC.oldPos.Length * 1.1f;
                    int num258 = rCurrentNPC.oldPos.Length - 1;
                    while ((float)num258 >= 0f)
                    {
                        float num259 = (float)(rCurrentNPC.oldPos.Length - num258) / (float)rCurrentNPC.oldPos.Length;
                        Microsoft.Xna.Framework.Color white6 = Microsoft.Xna.Framework.Color.White;
                        white6 *= 1f - num257 * (float)num258 / 1f;
                        white6.A = (byte)((float)(int)white6.A * (1f - num259));
                        mySpriteBatch.Draw(value70, vector68 + rCurrentNPC.oldPos[num258] - rCurrentNPC.position, null, white6, rCurrentNPC.oldRot[num258], halfSize, rCurrentNPC.scale * MathHelper.Lerp(0.8f, 0.3f, num259), spriteEffects, 0f);
                        num256++;
                        num258--;
                    }
                    value70 = TextureAssets.Extra[57].Value;
                    mySpriteBatch.Draw(value70, vector68, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), 0f, value70.Size() / 2f, rCurrentNPC.scale, spriteEffects, 0f);
                    break;
                }
                case 370:
                case 372:
                case 373:
                {
                    Texture2D value64 = TextureAssets.Npc[type].Value;
                    Microsoft.Xna.Framework.Color value65 = Microsoft.Xna.Framework.Color.White;
                    float amount8 = 0f;
                    bool flag12 = type == 370 && rCurrentNPC.ai[0] > 4f;
                    bool num239 = type == 370 && rCurrentNPC.ai[0] > 9f;
                    int num240 = 120;
                    int num241 = 60;
                    Microsoft.Xna.Framework.Color color43 = npcColor;
                    if (num239)
                    {
                        npcColor = buffColor(npcColor, 0.4f, 0.8f, 0.4f, 1f);
                    }
                    else if (flag12)
                    {
                        npcColor = buffColor(npcColor, 0.5f, 0.7f, 0.5f, 1f);
                    }
                    else if (type == 370 && rCurrentNPC.ai[0] == 4f && rCurrentNPC.ai[2] > (float)num240)
                    {
                        float num242 = rCurrentNPC.ai[2] - (float)num240;
                        num242 /= (float)num241;
                        npcColor = buffColor(npcColor, 1f - 0.5f * num242, 1f - 0.3f * num242, 1f - 0.5f * num242, 1f);
                    }
                    int num243 = 10;
                    int num244 = 2;
                    switch (type)
                    {
                    case 370:
                        if (rCurrentNPC.ai[0] == -1f)
                        {
                            num243 = 0;
                        }
                        if (rCurrentNPC.ai[0] == 0f || rCurrentNPC.ai[0] == 5f || rCurrentNPC.ai[0] == 10f)
                        {
                            num243 = 7;
                        }
                        if (rCurrentNPC.ai[0] == 1f)
                        {
                            value65 = Microsoft.Xna.Framework.Color.Blue;
                            amount8 = 0.5f;
                        }
                        else
                        {
                            color43 = npcColor;
                        }
                        break;
                    case 372:
                    case 373:
                        if (rCurrentNPC.ai[0] == 1f)
                        {
                            value65 = Microsoft.Xna.Framework.Color.Blue;
                            amount8 = 0.5f;
                        }
                        break;
                    }
                    for (int num245 = 1; num245 < num243; num245 += num244)
                    {
                        _ = ref rCurrentNPC.oldPos[num245];
                        Microsoft.Xna.Framework.Color value66 = color43;
                        value66 = Microsoft.Xna.Framework.Color.Lerp(value66, value65, amount8);
                        value66 = rCurrentNPC.GetAlpha(value66);
                        value66 *= (float)(num243 - num245) / 15f;
                        Vector2 position22 = rCurrentNPC.oldPos[num245] + new Vector2(rCurrentNPC.width, rCurrentNPC.height) / 2f - screenPos;
                        position22 -= new Vector2(value64.Width, value64.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position22 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value64, position22, rCurrentNPC.frame, value66, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    int num246 = 0;
                    float num247 = 0f;
                    float num248 = 0f;
                    if (type == 370)
                    {
                        if (rCurrentNPC.ai[0] == -1f)
                        {
                            num246 = 0;
                        }
                        if (rCurrentNPC.ai[0] == 3f || rCurrentNPC.ai[0] == 8f)
                        {
                            int num249 = 60;
                            int num250 = 30;
                            if (rCurrentNPC.ai[2] > (float)num249)
                            {
                                num246 = 6;
                                num247 = 1f - (float)Math.Cos((rCurrentNPC.ai[2] - (float)num249) / (float)num250 * ((float)Math.PI * 2f));
                                num247 /= 3f;
                                num248 = 40f;
                            }
                        }
                        if (rCurrentNPC.ai[0] == 4f && rCurrentNPC.ai[2] > (float)num240)
                        {
                            num246 = 6;
                            num247 = 1f - (float)Math.Cos((rCurrentNPC.ai[2] - (float)num240) / (float)num241 * ((float)Math.PI * 2f));
                            num247 /= 3f;
                            num248 = 60f;
                        }
                        if (rCurrentNPC.ai[0] == 9f && rCurrentNPC.ai[2] > (float)num240)
                        {
                            num246 = 6;
                            num247 = 1f - (float)Math.Cos((rCurrentNPC.ai[2] - (float)num240) / (float)num241 * ((float)Math.PI * 2f));
                            num247 /= 3f;
                            num248 = 60f;
                        }
                        if (rCurrentNPC.ai[0] == 12f)
                        {
                            num246 = 6;
                            num247 = 1f - (float)Math.Cos(rCurrentNPC.ai[2] / 30f * ((float)Math.PI * 2f));
                            num247 /= 3f;
                            num248 = 20f;
                        }
                    }
                    for (int num251 = 0; num251 < num246; num251++)
                    {
                        Microsoft.Xna.Framework.Color value67 = npcColor;
                        value67 = Microsoft.Xna.Framework.Color.Lerp(value67, value65, amount8);
                        value67 = rCurrentNPC.GetAlpha(value67);
                        value67 *= 1f - num247;
                        Vector2 position23 = rCurrentNPC.Center + ((float)num251 / (float)num246 * ((float)Math.PI * 2f) + rCurrentNPC.rotation).ToRotationVector2() * num248 * num247 - screenPos;
                        position23 -= new Vector2(value64.Width, value64.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position23 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value64, position23, rCurrentNPC.frame, value67, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    Vector2 position24 = rCurrentNPC.Center - screenPos;
                    position24 -= new Vector2(value64.Width, value64.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    position24 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(value64, position24, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    if (type != 370 || !(rCurrentNPC.ai[0] >= 4f))
                    {
                        break;
                    }
                    value64 = TextureAssets.DukeFishron.Value;
                    Microsoft.Xna.Framework.Color color44 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.White, Microsoft.Xna.Framework.Color.Yellow, 0.5f);
                    value65 = Microsoft.Xna.Framework.Color.Yellow;
                    amount8 = 1f;
                    num247 = 0.5f;
                    num248 = 10f;
                    num244 = 1;
                    if (rCurrentNPC.ai[0] == 4f)
                    {
                        float num252 = rCurrentNPC.ai[2] - (float)num240;
                        num252 /= (float)num241;
                        value65 *= num252;
                        color44 *= num252;
                    }
                    if (rCurrentNPC.ai[0] == 12f)
                    {
                        float num253 = rCurrentNPC.ai[2];
                        num253 /= 30f;
                        if (num253 > 0.5f)
                        {
                            num253 = 1f - num253;
                        }
                        num253 *= 2f;
                        num253 = 1f - num253;
                        value65 *= num253;
                        color44 *= num253;
                    }
                    for (int num254 = 1; num254 < num243; num254 += num244)
                    {
                        _ = ref rCurrentNPC.oldPos[num254];
                        Microsoft.Xna.Framework.Color value68 = color44;
                        value68 = Microsoft.Xna.Framework.Color.Lerp(value68, value65, amount8);
                        value68 *= (float)(num243 - num254) / 15f;
                        Vector2 position25 = rCurrentNPC.oldPos[num254] + new Vector2(rCurrentNPC.width, rCurrentNPC.height) / 2f - screenPos;
                        position25 -= new Vector2(value64.Width, value64.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position25 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value64, position25, rCurrentNPC.frame, value68, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    for (int num255 = 1; num255 < num246; num255++)
                    {
                        Microsoft.Xna.Framework.Color value69 = color44;
                        value69 = Microsoft.Xna.Framework.Color.Lerp(value69, value65, amount8);
                        value69 = rCurrentNPC.GetAlpha(value69);
                        value69 *= 1f - num247;
                        Vector2 position26 = rCurrentNPC.Center + ((float)num255 / (float)num246 * ((float)Math.PI * 2f) + rCurrentNPC.rotation).ToRotationVector2() * num248 * num247 - screenPos;
                        position26 -= new Vector2(value64.Width, value64.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position26 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value64, position26, rCurrentNPC.frame, value69, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    mySpriteBatch.Draw(value64, position24, rCurrentNPC.frame, color44, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    break;
                }
                case 439:
                case 440:
                {
                    int num260 = rCurrentNPC.frame.Y / (TextureAssets.Npc[type].Height() / npcFrameCount[type]);
                    Texture2D value71 = TextureAssets.Npc[type].Value;
                    Texture2D value72 = TextureAssets.Extra[30].Value;
                    Microsoft.Xna.Framework.Rectangle rectangle11 = value72.Frame();
                    rectangle11.Height /= 2;
                    if (num260 >= 4)
                    {
                        rectangle11.Y += rectangle11.Height;
                    }
                    Microsoft.Xna.Framework.Color white7 = Microsoft.Xna.Framework.Color.White;
                    float amount9 = 0f;
                    Microsoft.Xna.Framework.Color color45 = npcColor;
                    int num261 = 0;
                    int num262 = 0;
                    int num263 = 0;
                    if (rCurrentNPC.ai[0] == -1f)
                    {
                        if (rCurrentNPC.ai[1] >= 320f && rCurrentNPC.ai[1] < 960f)
                        {
                            white7 = Microsoft.Xna.Framework.Color.White;
                            amount9 = 0.5f;
                            num261 = 6;
                            num262 = 2;
                            num263 = 1;
                        }
                    }
                    else if (rCurrentNPC.ai[0] == 1f)
                    {
                        white7 = Microsoft.Xna.Framework.Color.White;
                        amount9 = 0.5f;
                        num261 = 4;
                        num262 = 2;
                        num263 = 1;
                    }
                    else
                    {
                        color45 = npcColor;
                    }
                    for (int num264 = num263; num264 < num261; num264 += num262)
                    {
                        _ = ref rCurrentNPC.oldPos[num264];
                        Microsoft.Xna.Framework.Color value73 = color45;
                        value73 = Microsoft.Xna.Framework.Color.Lerp(value73, white7, amount9);
                        value73 = rCurrentNPC.GetAlpha(value73);
                        value73 *= (float)(num261 - num264) / (float)num261;
                        value73.A = 100;
                        Vector2 position27 = rCurrentNPC.oldPos[num264] + new Vector2(rCurrentNPC.width, rCurrentNPC.height) / 2f - screenPos;
                        position27 -= rectangle11.Size() * rCurrentNPC.scale / 2f;
                        position27 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value72, position27, rectangle11, value73, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    int num265 = 0;
                    float num266 = 0f;
                    float num267 = 0f;
                    if (rCurrentNPC.ai[0] == 5f && rCurrentNPC.ai[1] >= 0f && rCurrentNPC.ai[1] < 30f)
                    {
                        num265 = 4;
                        num266 = 1f - (float)Math.Cos((rCurrentNPC.ai[1] - 0f) / 30f * (float)Math.PI);
                        num266 /= 2f;
                        num267 = 70f;
                    }
                    for (int num268 = 0; num268 < num265; num268++)
                    {
                        Microsoft.Xna.Framework.Color value74 = npcColor;
                        value74 = Microsoft.Xna.Framework.Color.Lerp(value74, white7, amount9);
                        value74 = rCurrentNPC.GetAlpha(value74);
                        value74 *= 1f - num266;
                        Vector2 position28 = rCurrentNPC.Center + ((float)num268 / (float)num265 * ((float)Math.PI * 2f) + rCurrentNPC.rotation).ToRotationVector2() * num267 * num266 - screenPos;
                        position28 -= new Vector2(value71.Width, value71.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position28 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value72, position28, rectangle11, value74, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    Vector2 position29 = rCurrentNPC.Center - screenPos;
                    position29 -= new Vector2(value71.Width, value71.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    position29 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(value71, position29, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    break;
                }
                case 392:
                case 393:
                case 394:
                case 395:
                {
                    Texture2D value75 = TextureAssets.Npc[type].Value;
                    Vector2 vec = rCurrentNPC.Center - screenPos + Vector2.UnitY * rCurrentNPC.gfxOffY;
                    vec = vec.Floor();
                    float num269 = 0f;
                    if (type == 393)
                    {
                        num269 = -8f;
                    }
                    mySpriteBatch.Draw(value75, vec, rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize + Vector2.UnitY * num269, rCurrentNPC.scale, spriteEffects, 0f);
                    if (type == 392)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[48].Value, vec, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 0), rCurrentNPC.rotation, halfSize + Vector2.UnitY * num269, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    if (type == 395)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[49].Value, vec, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 0), rCurrentNPC.rotation, halfSize + Vector2.UnitY * num269, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    if (type == 394)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[50].Value, vec, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 0), rCurrentNPC.rotation, halfSize + Vector2.UnitY * num269, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    break;
                }
                case 83:
                case 84:
                case 179:
                    mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, Microsoft.Xna.Framework.Color.White, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    break;
                case 87:
                case 88:
                case 89:
                case 90:
                case 91:
                case 92:
                {
                    Microsoft.Xna.Framework.Color alpha13 = rCurrentNPC.GetAlpha(npcColor);
                    byte b3 = (byte)((tileColor.R + tileColor.G + tileColor.B) / 3);
                    if (alpha13.R < b3)
                    {
                        alpha13.R = b3;
                    }
                    if (alpha13.G < b3)
                    {
                        alpha13.G = b3;
                    }
                    if (alpha13.B < b3)
                    {
                        alpha13.B = b3;
                    }
                    mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, alpha13, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    break;
                }
                default:
                {
                    switch (type)
                    {
                    case 491:
                    {
                        Texture2D value38 = TextureAssets.Npc[rCurrentNPC.type].Value;
                        Microsoft.Xna.Framework.Rectangle frame3 = rCurrentNPC.frame;
                        Vector2 origin15 = frame3.OriginFlip(new Vector2(208f, 460f), spriteEffects);
                        Vector2 vector34 = rCurrentNPC.Center - screenPos;
                        Vector2 vector35 = new Vector2((!spriteEffects.HasFlag(SpriteEffects.FlipHorizontally)) ? 1 : (-1), 1f);
                        Microsoft.Xna.Framework.Color alpha7 = rCurrentNPC.GetAlpha(npcColor);
                        mySpriteBatch.Draw(value38, vector34, frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        int num89 = (int)rCurrentNPC.localAI[3] / 8;
                        value38 = TextureAssets.Extra[40].Value;
                        frame3 = value38.Frame(1, 4, 0, num89 % 4);
                        origin15 = frame3.Size() * new Vector2(0.5f, 1f);
                        mySpriteBatch.Draw(value38, vector34 + (new Vector2(102f, -384f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        value38 = TextureAssets.Extra[41].Value;
                        frame3 = value38.Frame(1, 8, 0, num89 % 8);
                        origin15 = frame3.Size() * new Vector2(0.5f, 0f) + new Vector2(0f, 10f);
                        for (int num90 = 0; num90 < 5; num90++)
                        {
                            mySpriteBatch.Draw(value38, vector34 + (new Vector2(-96 + 34 * num90, 40f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        value38 = TextureAssets.Extra[42].Value;
                        frame3 = value38.Frame(1, 4, 0, num89 % 4);
                        origin15 = frame3.Size() * new Vector2(0.5f, 0f);
                        for (int num91 = 0; num91 < 2; num91++)
                        {
                            mySpriteBatch.Draw(value38, vector34 + (new Vector2(158 - 106 * num91, -302f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        value38 = TextureAssets.Extra[43].Value;
                        frame3 = value38.Frame(1, 4, 0, num89 % 4);
                        origin15 = frame3.Size() * new Vector2(0.5f, 0f);
                        for (int num92 = 0; num92 < 2; num92++)
                        {
                            mySpriteBatch.Draw(value38, vector34 + (new Vector2(42 - 178 * num92, -444f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        value38 = TextureAssets.Extra[44].Value;
                        frame3 = value38.Frame(1, 4, 0, num89 % 4);
                        origin15 = frame3.Size() * new Vector2(0.5f, 0f);
                        mySpriteBatch.Draw(value38, vector34 + (new Vector2(-134f, -302f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        value38 = TextureAssets.Extra[45].Value;
                        frame3 = value38.Frame(1, 4, 0, (2 + num89) % 4);
                        origin15 = frame3.Size() * new Vector2(0.5f, 0f);
                        mySpriteBatch.Draw(value38, vector34 + (new Vector2(-60f, -330f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                        LoadNPC(492);
                        if (!TextureAssets.Npc[492].IsLoaded)
                        {
                            return;
                        }
                        value38 = TextureAssets.Npc[492].Value;
                        frame3 = value38.Frame(1, 9);
                        origin15 = frame3.Size() * new Vector2(0.5f, 0f) + new Vector2(0f, 10f);
                        for (int num93 = 0; num93 < 4; num93++)
                        {
                            int num94 = (int)rCurrentNPC.ai[num93];
                            if (num94 >= 0)
                            {
                                frame3.Y = npc[num94].frame.Y;
                                mySpriteBatch.Draw(value38, vector34 + (new Vector2(-122 + 68 * num93, -20f) * vector35).RotatedBy(rCurrentNPC.rotation), frame3, alpha7, rCurrentNPC.rotation, origin15, rCurrentNPC.scale, spriteEffects, 0f);
                            }
                        }
                        return;
                    }
                    case 398:
                    {
                        bool flag8 = false;
                        Texture2D value23 = TextureAssets.Npc[type].Value;
                        Texture2D value24 = TextureAssets.Extra[16].Value;
                        Texture2D value25 = TextureAssets.Extra[14].Value;
                        float num74 = 340f;
                        float num75 = 0.5f;
                        Vector2 vector20 = new Vector2(220f, -60f);
                        Vector2 vector21 = new Vector2(76f, 66f);
                        Texture2D value26 = TextureAssets.Extra[13].Value;
                        Vector2 origin10 = new Vector2(value26.Width, 278f);
                        Vector2 origin11 = new Vector2(0f, 278f);
                        Vector2 vector22 = new Vector2(0f, 76f);
                        Vector2 center2 = rCurrentNPC.Center;
                        Microsoft.Xna.Framework.Point point = (rCurrentNPC.Center + new Vector2(0f, -150f)).ToTileCoordinates();
                        Microsoft.Xna.Framework.Color alpha4 = rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.Lerp(Lighting.GetColor(point.X, point.Y), Microsoft.Xna.Framework.Color.White, 0.3f));
                        for (int num76 = 0; num76 < 2; num76++)
                        {
                            bool flag9 = num76 == 0;
                            Vector2 vector23 = new Vector2((!flag9) ? 1 : (-1), 1f);
                            int num77 = -1;
                            for (int num78 = 0; num78 < 200; num78++)
                            {
                                if (npc[num78].active && npc[num78].type == 397 && npc[num78].ai[2] == (float)num76 && npc[num78].ai[3] == (float)rCurrentNPC.whoAmI)
                                {
                                    num77 = num78;
                                    break;
                                }
                            }
                            if (num77 != -1)
                            {
                                Vector2 vector24 = center2 + vector20 * vector23;
                                Vector2 vector25 = (npc[num77].Center + vector22 - vector24) * num75;
                                if (flag8)
                                {
                                    dust[Dust.NewDust(vector24 + vector25, 0, 0, 6)].noGravity = true;
                                }
                                float num79 = (float)Math.Acos(vector25.Length() / num74) * (0f - vector23.X);
                                SpriteEffects effects = ((!flag9) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
                                Vector2 origin12 = vector21;
                                if (!flag9)
                                {
                                    origin12.X = (float)value25.Width - origin12.X;
                                }
                                mySpriteBatch.Draw(value25, vector24 - screenPos, null, alpha4, vector25.ToRotation() - num79 - (float)Math.PI / 2f, origin12, 1f, effects, 0f);
                                if (flag8)
                                {
                                    dust[Dust.NewDust(vector24, 0, 0, 6)].noGravity = true;
                                }
                                if (flag8)
                                {
                                    dust[Dust.NewDust(center2, 0, 0, 6)].noGravity = true;
                                }
                                if (flag8)
                                {
                                    dust[Dust.NewDust(vector24 + new Vector2(0f, num74).RotatedBy(vector25.ToRotation() - num79 - (float)Math.PI / 2f), 0, 0, 6)].noGravity = true;
                                }
                            }
                        }
                        mySpriteBatch.Draw(value26, center2 - screenPos, null, alpha4, 0f, origin10, 1f, SpriteEffects.None, 0f);
                        mySpriteBatch.Draw(value26, center2 - screenPos, null, alpha4, 0f, origin11, 1f, SpriteEffects.FlipHorizontally, 0f);
                        mySpriteBatch.Draw(value24, center2 - screenPos, null, alpha4, 0f, new Vector2(112f, 101f), 1f, SpriteEffects.None, 0f);
                        mySpriteBatch.Draw(value23, center2 - screenPos, rCurrentNPC.frame, alpha4, 0f, rCurrentNPC.frame.Size() / 2f, 1f, SpriteEffects.None, 0f);
                        return;
                    }
                    case 397:
                    {
                        Texture2D value39 = TextureAssets.Npc[type].Value;
                        float num95 = 0.5f;
                        Vector2 vector36 = new Vector2(220f, -60f);
                        Vector2 vector37 = new Vector2(0f, 76f);
                        Texture2D value40 = TextureAssets.Extra[15].Value;
                        Vector2 vector38 = new Vector2(60f, 30f);
                        float num96 = 340f;
                        Vector2 center3 = npc[(int)rCurrentNPC.ai[3]].Center;
                        Microsoft.Xna.Framework.Point point4 = rCurrentNPC.Center.ToTileCoordinates();
                        Microsoft.Xna.Framework.Color alpha8 = rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.Lerp(Lighting.GetColor(point4.X, point4.Y), Microsoft.Xna.Framework.Color.White, 0.3f));
                        bool flag10 = rCurrentNPC.ai[2] == 0f;
                        Vector2 vector39 = new Vector2((!flag10) ? 1 : (-1), 1f);
                        Vector2 origin16 = new Vector2(120f, 180f);
                        if (!flag10)
                        {
                            origin16.X = (float)value39.Width - origin16.X;
                        }
                        Texture2D value41 = TextureAssets.Extra[17].Value;
                        Texture2D value42 = TextureAssets.Extra[19].Value;
                        Vector2 vector40 = new Vector2(26f, 42f);
                        if (!flag10)
                        {
                            vector40.X = (float)value41.Width - vector40.X;
                        }
                        Vector2 vector41 = new Vector2(30f, 66f);
                        Vector2 vector42 = new Vector2(1f * (0f - vector39.X), 3f);
                        Texture2D value43 = TextureAssets.Extra[26].Value;
                        Microsoft.Xna.Framework.Rectangle value44 = value43.Frame();
                        value44.Height /= 4;
                        Vector2 vector43 = center3 + vector36 * vector39;
                        Vector2 vector44 = rCurrentNPC.Center + vector37;
                        Vector2 v = vector43 - vector44;
                        v *= 1f - num95;
                        Vector2 origin17 = vector38;
                        if (!flag10)
                        {
                            origin17.X = (float)value40.Width - origin17.X;
                        }
                        float num97 = (float)Math.Acos(v.Length() / num96) * (0f - vector39.X);
                        mySpriteBatch.Draw(value40, vector44 - screenPos, null, alpha8, v.ToRotation() + num97 - (float)Math.PI / 2f, origin17, 1f, spriteEffects, 0f);
                        if (rCurrentNPC.ai[0] == -2f)
                        {
                            int num98 = (int)rCurrentNPC.ai[1];
                            num98 /= 8;
                            value44.Y += value44.Height * num98;
                            mySpriteBatch.Draw(value43, rCurrentNPC.Center - screenPos, value44, alpha8, 0f, vector40 - new Vector2(4f, 4f), 1f, spriteEffects, 0f);
                        }
                        else
                        {
                            mySpriteBatch.Draw(value41, rCurrentNPC.Center - screenPos, null, alpha8, 0f, vector40, 1f, spriteEffects, 0f);
                            Vector2 vector45 = Utils.Vector2FromElipse(rCurrentNPC.localAI[0].ToRotationVector2(), vector41 * rCurrentNPC.localAI[1]);
                            mySpriteBatch.Draw(value42, rCurrentNPC.Center - screenPos + vector45 + vector42, null, alpha8, 0f, new Vector2(value42.Width, value42.Height) / 2f, 1f, SpriteEffects.None, 0f);
                        }
                        mySpriteBatch.Draw(value39, rCurrentNPC.Center - screenPos, rCurrentNPC.frame, alpha8, 0f, origin16, 1f, spriteEffects, 0f);
                        return;
                    }
                    case 396:
                    {
                        Texture2D value29 = TextureAssets.Npc[type].Value;
                        Vector2 origin13 = new Vector2(191f, 130f);
                        Texture2D value30 = TextureAssets.Extra[18].Value;
                        Texture2D value31 = TextureAssets.Extra[19].Value;
                        Vector2 vector26 = new Vector2(19f, 34f);
                        Vector2 vector27 = new Vector2(27f, 59f);
                        Vector2 vector28 = new Vector2(0f, 0f);
                        Texture2D value32 = TextureAssets.Extra[25].Value;
                        Vector2 vector29 = new Vector2(0f, 214f).RotatedBy(rCurrentNPC.rotation);
                        Microsoft.Xna.Framework.Rectangle rectangle9 = value32.Frame();
                        rectangle9.Height /= 3;
                        rectangle9.Y += rectangle9.Height * (int)(rCurrentNPC.localAI[2] / 7f);
                        Texture2D value33 = TextureAssets.Extra[29].Value;
                        Vector2 vector30 = new Vector2(0f, 4f).RotatedBy(rCurrentNPC.rotation);
                        Microsoft.Xna.Framework.Rectangle rectangle10 = value33.Frame();
                        rectangle10.Height /= 4;
                        rectangle10.Y += rectangle10.Height * (int)(rCurrentNPC.localAI[3] / 5f);
                        Texture2D value34 = TextureAssets.Extra[26].Value;
                        Microsoft.Xna.Framework.Rectangle value35 = value34.Frame();
                        value35.Height /= 4;
                        _ = npc[(int)rCurrentNPC.ai[3]].Center;
                        Microsoft.Xna.Framework.Point point2 = rCurrentNPC.Center.ToTileCoordinates();
                        Microsoft.Xna.Framework.Color alpha5 = rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.Lerp(Lighting.GetColor(point2.X, point2.Y), Microsoft.Xna.Framework.Color.White, 0.3f));
                        if (rCurrentNPC.ai[0] < 0f)
                        {
                            int num84 = (int)rCurrentNPC.ai[1];
                            num84 /= 8;
                            value35.Y += value35.Height * num84;
                            mySpriteBatch.Draw(value34, rCurrentNPC.Center - screenPos, value35, alpha5, rCurrentNPC.rotation, vector26 + new Vector2(4f, 4f), 1f, spriteEffects, 0f);
                        }
                        else
                        {
                            mySpriteBatch.Draw(value30, rCurrentNPC.Center - screenPos, null, alpha5, rCurrentNPC.rotation, vector26, 1f, spriteEffects, 0f);
                            Vector2 vector31 = Utils.Vector2FromElipse(rCurrentNPC.localAI[0].ToRotationVector2(), vector27 * rCurrentNPC.localAI[1]);
                            mySpriteBatch.Draw(value31, rCurrentNPC.Center - screenPos + vector31 + vector28, null, alpha5, rCurrentNPC.rotation, new Vector2(value31.Width, value31.Height) / 2f, 1f, SpriteEffects.None, 0f);
                        }
                        mySpriteBatch.Draw(value29, rCurrentNPC.Center - screenPos, rCurrentNPC.frame, alpha5, rCurrentNPC.rotation, origin13, 1f, spriteEffects, 0f);
                        mySpriteBatch.Draw(value33, (rCurrentNPC.Center - screenPos + vector30).Floor(), rectangle10, alpha5, rCurrentNPC.rotation, rectangle10.Size() / 2f, 1f, spriteEffects, 0f);
                        mySpriteBatch.Draw(value32, (rCurrentNPC.Center - screenPos + vector29).Floor(), rectangle9, alpha5, rCurrentNPC.rotation, rectangle9.Size() / 2f, 1f, spriteEffects, 0f);
                        return;
                    }
                    case 400:
                    {
                        Texture2D value36 = TextureAssets.Npc[type].Value;
                        Texture2D value37 = TextureAssets.Extra[19].Value;
                        Vector2 origin14 = new Vector2(40f, 40f);
                        Vector2 vector32 = new Vector2(30f, 30f);
                        _ = rCurrentNPC.Center;
                        Microsoft.Xna.Framework.Point point3 = rCurrentNPC.Center.ToTileCoordinates();
                        Microsoft.Xna.Framework.Color alpha6 = rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.Lerp(Lighting.GetColor(point3.X, point3.Y), Microsoft.Xna.Framework.Color.White, 0.3f));
                        mySpriteBatch.Draw(value36, rCurrentNPC.Center - screenPos, rCurrentNPC.frame, alpha6, rCurrentNPC.rotation, origin14, 1f, spriteEffects, 0f);
                        Vector2 vector33 = Utils.Vector2FromElipse(rCurrentNPC.localAI[0].ToRotationVector2(), vector32 * rCurrentNPC.localAI[1]);
                        mySpriteBatch.Draw(value37, rCurrentNPC.Center - screenPos + vector33, null, alpha6, rCurrentNPC.rotation, value37.Size() / 2f, rCurrentNPC.localAI[2], SpriteEffects.None, 0f);
                        return;
                    }
                    case 416:
                    {
                        int num85 = -1;
                        int num86 = (int)rCurrentNPC.ai[0];
                        Vector2 position15 = rCurrentNPC.position;
                        Vector2 spinningpoint3 = Vector2.Zero;
                        if (npc[num86].active && npc[num86].type == 415)
                        {
                            num85 = num86;
                        }
                        if (num85 != -1)
                        {
                            Vector2 position16 = rCurrentNPC.position;
                            rCurrentNPC.Bottom = npc[num85].Bottom;
                            position15 = rCurrentNPC.position;
                            rCurrentNPC.position = position16;
                            rCurrentNPC.gfxOffY = npc[num85].gfxOffY;
                            spinningpoint3 = npc[num85].velocity;
                        }
                        Microsoft.Xna.Framework.Rectangle frame2 = rCurrentNPC.frame;
                        mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(position15.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, position15.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame2, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        if (rCurrentNPC.color != default(Microsoft.Xna.Framework.Color))
                        {
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(position15.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, position15.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame2, rCurrentNPC.GetColor(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        mySpriteBatch.Draw(TextureAssets.GlowMask[156].Value, position15 + rCurrentNPC.Size * new Vector2(0.5f, 1f) - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        float num87 = 0.5f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.5f;
                        for (int num88 = 0; num88 < 4; num88++)
                        {
                            mySpriteBatch.Draw(TextureAssets.GlowMask[156].Value, position15 + rCurrentNPC.Size * new Vector2(0.5f, 1f) - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + spinningpoint3.RotatedBy((float)num88 * ((float)Math.PI / 2f)) * num87, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        return;
                    }
                    case 399:
                    {
                        Texture2D value27 = TextureAssets.Npc[type].Value;
                        (rCurrentNPC.position - screenPos + Vector2.UnitY * rCurrentNPC.gfxOffY).Floor();
                        float num80 = 5f;
                        for (int num81 = 0; (float)num81 < num80; num81++)
                        {
                            float num82 = 1f - (GlobalTimeWrappedHourly + (float)num81) % num80 / num80;
                            Microsoft.Xna.Framework.Color color22 = Microsoft.Xna.Framework.Color.LimeGreen;
                            if (rCurrentNPC.ai[0] == 1f)
                            {
                                color22 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.LimeGreen, Microsoft.Xna.Framework.Color.Red, MathHelper.Clamp(rCurrentNPC.ai[1] / 20f, 0f, 1f));
                            }
                            if (rCurrentNPC.ai[0] == 2f)
                            {
                                color22 = Microsoft.Xna.Framework.Color.Red;
                            }
                            color22 *= 1f - num82;
                            color22.A = 0;
                            for (int num83 = 0; num83 < 2; num83++)
                            {
                                mySpriteBatch.Draw(TextureAssets.Extra[27].Value, rCurrentNPC.Center - screenPos + Vector2.UnitY * (rCurrentNPC.gfxOffY - 4f + 6f), null, color22, (float)Math.PI / 2f, new Vector2(10f, 48f), num82 * 4f, SpriteEffects.None, 0f);
                            }
                        }
                        mySpriteBatch.Draw(value27, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        value27 = TextureAssets.GlowMask[100].Value;
                        mySpriteBatch.Draw(value27, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(127 - rCurrentNPC.alpha / 2, 127 - rCurrentNPC.alpha / 2, 127 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        value27 = TextureAssets.Extra[20].Value;
                        Microsoft.Xna.Framework.Rectangle value28 = value27.Frame(1, 4, 0, (int)rCurrentNPC.ai[0] + 1);
                        Vector2 position14 = new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)value27.Width * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY + 18f + 6f);
                        mySpriteBatch.Draw(value27, position14, value28, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        value27 = TextureAssets.GlowMask[101].Value;
                        mySpriteBatch.Draw(value27, position14, value28, new Microsoft.Xna.Framework.Color(127 - rCurrentNPC.alpha / 2, 127 - rCurrentNPC.alpha / 2, 127 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        return;
                    }
                    case 94:
                    {
                        for (int num73 = 1; num73 < 6; num73 += 2)
                        {
                            _ = ref rCurrentNPC.oldPos[num73];
                            Microsoft.Xna.Framework.Color alpha3 = rCurrentNPC.GetAlpha(npcColor);
                            alpha3.R = (byte)(alpha3.R * (10 - num73) / 15);
                            alpha3.G = (byte)(alpha3.G * (10 - num73) / 15);
                            alpha3.B = (byte)(alpha3.B * (10 - num73) / 15);
                            alpha3.A = (byte)(alpha3.A * (10 - num73) / 15);
                            alpha3 = rCurrentNPC.GetShimmerColor(alpha3);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num73].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num73].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, alpha3, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    case 384:
                        return;
                    }
                    if (type == 125 || type == 126 || type == 127 || type == 128 || type == 129 || type == 130 || type == 131 || (type == 139 && rCurrentNPC.ai[3] == 0f) || type == 140)
                    {
                        for (int num99 = 9; num99 >= 0; num99 -= 2)
                        {
                            _ = ref rCurrentNPC.oldPos[num99];
                            Microsoft.Xna.Framework.Color alpha9 = rCurrentNPC.GetAlpha(npcColor);
                            alpha9.R = (byte)(alpha9.R * (10 - num99) / 20);
                            alpha9.G = (byte)(alpha9.G * (10 - num99) / 20);
                            alpha9.B = (byte)(alpha9.B * (10 - num99) / 20);
                            alpha9.A = (byte)(alpha9.A * (10 - num99) / 20);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num99].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num99].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, alpha9, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    if (type == 417 && rCurrentNPC.ai[0] >= 6f && rCurrentNPC.ai[0] <= 6f)
                    {
                        for (int num100 = 5; num100 >= 0; num100--)
                        {
                            _ = ref rCurrentNPC.oldPos[num100];
                            Microsoft.Xna.Framework.Color alpha10 = rCurrentNPC.GetAlpha(npcColor);
                            alpha10.R = (byte)(alpha10.R * (10 - num100) / 20);
                            alpha10.G = (byte)(alpha10.G * (10 - num100) / 20);
                            alpha10.B = (byte)(alpha10.B * (10 - num100) / 20);
                            alpha10.A = (byte)(alpha10.A * (10 - num100) / 20);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num100].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num100].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, alpha10, rCurrentNPC.oldRot[num100], halfSize, MathHelper.Lerp(0.5f, 1f, (5f - (float)num100) / 6f), spriteEffects, 0f);
                        }
                    }
                    if (type == 419 && rCurrentNPC.ai[2] <= -9f)
                    {
                        int num101 = TextureAssets.GlowMask[154].Height() / npcFrameCount[type];
                        int num102 = rCurrentNPC.frame.Y / num101;
                        for (int num103 = 6; num103 >= 0; num103--)
                        {
                            _ = ref rCurrentNPC.oldPos[num103];
                            Microsoft.Xna.Framework.Color white3 = Microsoft.Xna.Framework.Color.White;
                            white3.R = (byte)(255 * (10 - num103) / 20);
                            white3.G = (byte)(255 * (10 - num103) / 20);
                            white3.B = (byte)(255 * (10 - num103) / 20);
                            white3.A = 0;
                            Microsoft.Xna.Framework.Rectangle frame4 = rCurrentNPC.frame;
                            int num104 = (num102 - 3 - num103) % 3;
                            if (num104 < 0)
                            {
                                num104 += 3;
                            }
                            num104 += 5;
                            frame4.Y = num101 * num104;
                            mySpriteBatch.Draw(TextureAssets.GlowMask[154].Value, new Vector2(rCurrentNPC.oldPos[num103].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num103].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), frame4, white3, rCurrentNPC.oldRot[num103], halfSize, MathHelper.Lerp(0.75f, 1.2f, (10f - (float)num103) / 10f), spriteEffects, 0f);
                        }
                    }
                    if (type == 418 && (rCurrentNPC.ai[0] == 2f || rCurrentNPC.ai[0] == 4f))
                    {
                        Texture2D value45 = TextureAssets.Extra[55].Value;
                        Vector2 origin18 = new Vector2(value45.Width / 2, value45.Height / 8 + 14);
                        int num105 = (int)rCurrentNPC.ai[1] / 2;
                        float num106 = -(float)Math.PI / 2f * (float)rCurrentNPC.spriteDirection;
                        float num107 = rCurrentNPC.ai[1] / 45f;
                        if (num107 > 1f)
                        {
                            num107 = 1f;
                        }
                        num105 %= 4;
                        for (int num108 = 6; num108 >= 0; num108--)
                        {
                            _ = ref rCurrentNPC.oldPos[num108];
                            Microsoft.Xna.Framework.Color value46 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Gold, Microsoft.Xna.Framework.Color.OrangeRed, num107);
                            value46 = Microsoft.Xna.Framework.Color.Lerp(value46, Microsoft.Xna.Framework.Color.Blue, (float)num108 / 12f);
                            value46.A = (byte)(64f * num107);
                            value46.R = (byte)(value46.R * (10 - num108) / 20);
                            value46.G = (byte)(value46.G * (10 - num108) / 20);
                            value46.B = (byte)(value46.B * (10 - num108) / 20);
                            value46.A = (byte)(value46.A * (10 - num108) / 20);
                            value46 *= num107;
                            int num109 = (num105 - num108) % 4;
                            if (num109 < 0)
                            {
                                num109 += 4;
                            }
                            Microsoft.Xna.Framework.Rectangle value47 = value45.Frame(1, 4, 0, num109);
                            mySpriteBatch.Draw(value45, new Vector2(rCurrentNPC.oldPos[num108].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num108].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), value47, value46, rCurrentNPC.oldRot[num108] + num106, origin18, MathHelper.Lerp(0.1f, 1.2f, (10f - (float)num108) / 10f), spriteEffects, 0f);
                        }
                    }
                    if (type == 516)
                    {
                        int num110 = TextureAssets.Npc[type].Height() / npcFrameCount[type];
                        int num111 = rCurrentNPC.frame.Y / num110;
                        for (int num112 = 6; num112 >= 0; num112--)
                        {
                            _ = ref rCurrentNPC.oldPos[num112];
                            Microsoft.Xna.Framework.Color white4 = Microsoft.Xna.Framework.Color.White;
                            white4.R = (byte)(255 * (10 - num112) / 20);
                            white4.G = (byte)(255 * (10 - num112) / 20);
                            white4.B = (byte)(255 * (10 - num112) / 20);
                            white4.A = (byte)(255 * (10 - num112) / 20);
                            white4 = Microsoft.Xna.Framework.Color.Lerp(white4, Microsoft.Xna.Framework.Color.Transparent, (float)num112 / 6f);
                            Microsoft.Xna.Framework.Rectangle frame5 = rCurrentNPC.frame;
                            int num113 = (num111 - 4 - num112) % 4;
                            if (num113 < 0)
                            {
                                num113 += 4;
                            }
                            frame5.Y = num110 * num113;
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num112].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num112].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), frame5, white4, rCurrentNPC.rotation, halfSize, MathHelper.Lerp(0.35f, 1.2f, (10f - (float)num112) / 10f), spriteEffects, 0f);
                        }
                    }
                    if (rCurrentNPC.type == 390 && rCurrentNPC.IsABestiaryIconDummy)
                    {
                        LoadNPC(391);
                        Texture2D value48 = TextureAssets.Npc[391].Value;
                        Microsoft.Xna.Framework.Rectangle value49 = value48.Frame(1, npcFrameCount[391], 0, (int)rCurrentNPC.localAI[3]);
                        Vector2 vector46 = new Vector2(-rCurrentNPC.width - 8, 10f);
                        mySpriteBatch.Draw(value48, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY) + vector46, value49, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    Microsoft.Xna.Framework.Rectangle frame6 = rCurrentNPC.frame;
                    if (type == 182 || type == 289)
                    {
                        frame6.Height -= 2;
                    }
                    switch (type)
                    {
                    case 420:
                    case 421:
                    case 423:
                    case 424:
                    {
                        float num117 = 9f + 3f * (float)Math.Cos((float)Math.PI * 2f * GlobalTimeWrappedHourly);
                        Vector2 spinningpoint5 = Vector2.UnitX * num117;
                        Microsoft.Xna.Framework.Color color24 = Microsoft.Xna.Framework.Color.Teal * (num117 / 12f) * 0.8f;
                        color24.A /= 2;
                        for (float num118 = 0f; num118 < (float)Math.PI * 2f; num118 += (float)Math.PI / 2f)
                        {
                            Vector2 vector49 = rCurrentNPC.position + spinningpoint5.RotatedBy(num118);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(vector49.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, vector49.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, color24, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    case 662:
                    {
                        float num114 = 4f + 2f * (float)Math.Cos((float)Math.PI * 2f * GlobalTimeWrappedHourly);
                        Vector2 spinningpoint4 = Vector2.UnitX * num114;
                        Microsoft.Xna.Framework.Color color23 = Microsoft.Xna.Framework.Color.Cyan * (num114 / 12f) * 0.4f;
                        color23.A /= 4;
                        for (float num115 = 0.9f; num115 >= 0f; num115 -= 0.125f)
                        {
                            Vector2 vector47 = rCurrentNPC.position - rCurrentNPC.velocity * 10f * num115;
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(vector47.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, vector47.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, color23 * (1f - num115), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        for (float num116 = 0f; num116 < (float)Math.PI * 2f; num116 += (float)Math.PI / 2f)
                        {
                            Vector2 vector48 = rCurrentNPC.position + spinningpoint4.RotatedBy(num116);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(vector48.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, vector48.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, color23, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        break;
                    }
                    }
                    if (rCurrentNPC.aiStyle == 7)
                    {
                        DrawNPCExtras(rCurrentNPC, beforeDraw: true, num36, num35, npcColor, halfSize, spriteEffects, screenPos);
                    }
                    if (type == 346 && (double)rCurrentNPC.life < (double)rCurrentNPC.lifeMax * 0.5)
                    {
                        mySpriteBatch.Draw(TextureAssets.SantaTank.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 356)
                    {
                        frame6.Height--;
                        mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 360)
                    {
                        float num119 = 0f;
                        if (rCurrentNPC.ai[2] == 0f)
                        {
                            if (rCurrentNPC.rotation == 3.14f || rCurrentNPC.rotation == -3.14f)
                            {
                                num36 = 2f;
                            }
                            if (rCurrentNPC.direction < 0 && (rCurrentNPC.rotation == 1.57f || rCurrentNPC.rotation == 4.71f))
                            {
                                num119 = 1f;
                            }
                            if (rCurrentNPC.direction > 0 && (rCurrentNPC.rotation == 1.57f || rCurrentNPC.rotation == 4.71f))
                            {
                                num119 = -1f;
                            }
                        }
                        mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale + num119, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 655)
                    {
                        float num120 = 0f;
                        if (rCurrentNPC.ai[2] == 0f)
                        {
                            if (rCurrentNPC.rotation == 3.14f || rCurrentNPC.rotation == -3.14f)
                            {
                                num36 = 2f;
                            }
                            if (rCurrentNPC.direction < 0 && (rCurrentNPC.rotation == 1.57f || rCurrentNPC.rotation == 4.71f))
                            {
                                num120 = 1f;
                            }
                            if (rCurrentNPC.direction > 0 && (rCurrentNPC.rotation == 1.57f || rCurrentNPC.rotation == 4.71f))
                            {
                                num120 = -1f;
                            }
                        }
                        mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale + num120, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.Orange), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 266 && rCurrentNPC.life < rCurrentNPC.lifeMax && (expertMode || getGoodWorld))
                    {
                        Microsoft.Xna.Framework.Color alpha11 = rCurrentNPC.GetAlpha(npcColor);
                        float num121 = 1f - (float)rCurrentNPC.life / (float)rCurrentNPC.lifeMax;
                        if (expertMode)
                        {
                            num121 *= 2f;
                        }
                        num121 *= num121;
                        if (getGoodWorld)
                        {
                            num121 = 1f;
                        }
                        num121 = MathHelper.Clamp(num121, 0f, 1f);
                        alpha11.R = (byte)((float)(int)alpha11.R * num121);
                        alpha11.G = (byte)((float)(int)alpha11.G * num121);
                        alpha11.B = (byte)((float)(int)alpha11.B * num121);
                        alpha11.A = (byte)((float)(int)alpha11.A * num121);
                        for (int num122 = 0; num122 < 4; num122++)
                        {
                            Vector2 position17 = rCurrentNPC.position;
                            float num123 = Math.Abs(rCurrentNPC.Center.X - Main.player[myPlayer].Center.X);
                            float num124 = Math.Abs(rCurrentNPC.Center.Y - Main.player[myPlayer].Center.Y);
                            if (num122 == 0 || num122 == 2)
                            {
                                position17.X = Main.player[myPlayer].Center.X + num123;
                            }
                            else
                            {
                                position17.X = Main.player[myPlayer].Center.X - num123;
                            }
                            position17.X -= rCurrentNPC.width / 2;
                            if (num122 == 0 || num122 == 1)
                            {
                                position17.Y = Main.player[myPlayer].Center.Y + num124;
                            }
                            else
                            {
                                position17.Y = Main.player[myPlayer].Center.Y - num124;
                            }
                            position17.Y -= rCurrentNPC.height / 2;
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(position17.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, position17.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, alpha11, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 421 && rCurrentNPC.ai[0] == 5f)
                    {
                        Player player = Main.player[rCurrentNPC.target];
                        if (player.gravDir == -1f)
                        {
                            spriteEffects |= SpriteEffects.FlipVertically;
                        }
                        mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(player.direction * 4, player.gfxOffY) + ((player.gravDir == 1f) ? player.Top : player.Bottom) - screenPos, frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, frame6.Size() / 2f, rCurrentNPC.scale, spriteEffects, 0f);
                        mySpriteBatch.Draw(TextureAssets.GlowMask[146].Value, new Vector2(player.direction * 4, player.gfxOffY) + ((player.gravDir == 1f) ? player.Top : player.Bottom) - screenPos, frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, frame6.Size() / 2f, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else
                    {
                        switch (type)
                        {
                        case 518:
                        {
                            Vector2 vector53 = new Vector2(-10f, 0f);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize + vector53, rCurrentNPC.scale, spriteEffects, 0f);
                            if (rCurrentNPC.color != default(Microsoft.Xna.Framework.Color))
                            {
                                mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetColor(npcColor), rCurrentNPC.rotation, halfSize + vector53, rCurrentNPC.scale, spriteEffects, 0f);
                            }
                            break;
                        }
                        case 676:
                        case 681:
                        {
                            if (!rCurrentNPC.IsABestiaryIconDummy)
                            {
                                mySpriteBatch.End();
                                mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
                            }
                            DrawData value50 = new DrawData(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects);
                            GameShaders.Misc["RainbowTownSlime"].Apply(value50);
                            value50.Draw(mySpriteBatch);
                            pixelShader.CurrentTechnique.Passes[0].Apply();
                            if (!rCurrentNPC.IsABestiaryIconDummy)
                            {
                                mySpriteBatch.End();
                                mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
                            }
                            break;
                        }
                        case 685:
                        {
                            Vector2 scale4 = new Vector2(rCurrentNPC.scale);
                            float num131 = rCurrentNPC.rotation;
                            int num132 = 9;
                            Vector2 vector50 = rCurrentNPC.oldPos[num132];
                            if (vector50 != Vector2.Zero && rCurrentNPC.velocity.Y == 0f)
                            {
                                Vector2 position18 = rCurrentNPC.position;
                                Vector2 vector51 = vector50 - position18;
                                float num133 = (float)Math.Sin(vector51.X / 30f * ((float)Math.PI * 2f));
                                float num134 = (float)Math.Sin(vector51.Y / 30f * ((float)Math.PI * 2f));
                                float num135 = Utils.Remap(vector51.Length(), 0f, 30f, 0f, 1f);
                                scale4.X += num133 * num135 * 0.25f;
                                scale4.Y += num134 * num135 * 0.25f;
                                float num136 = (float)Math.Sin(Utils.Remap(vector51.Length(), 0f, 20f, 0f, 1f) * ((float)Math.PI * 2f));
                                num131 += num136 * ((float)Math.PI / 4f) * 0.1f * (float)rCurrentNPC.spriteDirection;
                            }
                            Vector2 vector52 = new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - 2f - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY);
                            if (rCurrentNPC.velocity.Y == 0f)
                            {
                                vector52 = vector52.Floor();
                                int num137 = 2;
                                float num138 = vector52.X % 16f;
                                if (num138 < (float)num137)
                                {
                                    vector52.X -= num138;
                                }
                                if (num138 > (float)(16 - num137))
                                {
                                    vector52.X += 16f - num138;
                                }
                            }
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, vector52, frame6, rCurrentNPC.GetAlpha(npcColor), num131, halfSize, scale4, spriteEffects, 0f);
                            break;
                        }
                        case 267:
                        {
                            Vector2 position19 = rCurrentNPC.Center + new Vector2(0f, num36 + num35 + rCurrentNPC.gfxOffY) - screenPos;
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, position19, frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            if (rCurrentNPC.color != default(Microsoft.Xna.Framework.Color))
                            {
                                mySpriteBatch.Draw(TextureAssets.Npc[type].Value, position19, frame6, rCurrentNPC.GetColor(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            }
                            break;
                        }
                        default:
                            if (rCurrentNPC.aiStyle == 7 && rCurrentNPC.ai[0] == 25f)
                            {
                                int num125 = type;
                                float num126 = Utils.Remap(rCurrentNPC.ai[1], 0f, 60f, 0f, 1f);
                                mySpriteBatch.End();
                                mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
                                DrawData drawData = new DrawData(TextureAssets.Npc[num125].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, Microsoft.Xna.Framework.Color.White * Utils.Remap(num126, 0f, 1f, 0f, 1f) * ((float)(int)rCurrentNPC.GetAlpha(npcColor).A / 255f), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects);
                                drawData.shader = ContentSamples.CommonlyUsedContentSamples.ColorOnlyShaderIndex;
                                GameShaders.Armor.Apply(ContentSamples.CommonlyUsedContentSamples.ColorOnlyShaderIndex, rCurrentNPC, drawData);
                                float num127 = Utils.Remap(rCurrentNPC.ai[1], 45f, 90f, 0f, 1f);
                                for (float num128 = 0f; num128 < 1f; num128 += 1f / 6f)
                                {
                                    DrawData drawData2 = drawData;
                                    drawData2.color = hslToRgb(num128, 0.9f, 0.65f) * num127 * 0.5f;
                                    drawData2.position += ((GlobalTimeWrappedHourly + num128) * ((float)Math.PI * 2f)).ToRotationVector2() * 4f * num127;
                                    drawData2.Draw(mySpriteBatch);
                                }
                                drawData.Draw(mySpriteBatch);
                                pixelShader.CurrentTechnique.Passes[0].Apply();
                                Microsoft.Xna.Framework.Color drawColor = new Microsoft.Xna.Framework.Color(255, 255, 255, 0);
                                float num129 = (float)Math.Sin(timeForVisualEffects * 6.2831854820251465 / 20.0);
                                DrawPrettyStarSparkle(num126, SpriteEffects.None, drawData.position, drawColor, hslToRgb(GlobalTimeWrappedHourly % 1f, 1f, 0.65f, 127), Utils.Remap(rCurrentNPC.ai[1], 30f, 60f, 0f, 30f), 0f, 30f, 30f, 36f, 0f, new Vector2(1.5f, 2.5f) * (1f + num129 * 0.025f), new Vector2(2f, 2f));
                                DrawPrettyStarSparkle(num126, SpriteEffects.None, drawData.position, drawColor, hslToRgb(GlobalTimeWrappedHourly % 1f, 1f, 0.65f, 127), Utils.Remap(rCurrentNPC.ai[1], 30f, 60f, 0f, 30f), 0f, 30f, 30f, 36f, (float)Math.PI / 4f, new Vector2(2.5f, 2.5f) * (1f + num129 * 0.025f), new Vector2(1f, 1f));
                                mySpriteBatch.End();
                                mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
                            }
                            else
                            {
                                int num130 = type;
                                if (NPC.IsMechQueenUp && num130 == 134)
                                {
                                    num130 = 136;
                                    LoadNPC(num130);
                                }
                                mySpriteBatch.Draw(TextureAssets.Npc[num130].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                if (rCurrentNPC.color != default(Microsoft.Xna.Framework.Color))
                                {
                                    mySpriteBatch.Draw(TextureAssets.Npc[num130].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetColor(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                            }
                            break;
                        }
                    }
                    if (rCurrentNPC.confused)
                    {
                        mySpriteBatch.Draw(TextureAssets.Confuse.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 - (float)TextureAssets.Confuse.Height() - 20f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Confuse.Width(), TextureAssets.Confuse.Height()), rCurrentNPC.GetShimmerColor(new Microsoft.Xna.Framework.Color(250, 250, 250, 70)), rCurrentNPC.velocity.X * -0.05f, new Vector2(TextureAssets.Confuse.Width() / 2, TextureAssets.Confuse.Height() / 2), essScale + 0.2f, SpriteEffects.None, 0f);
                    }
                    if (type == 247 || type == 248)
                    {
                        Vector2 vector54 = new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY);
                        Texture2D value51 = TextureAssets.Npc[type].Value;
                        if (rCurrentNPC.ai[0] == 1f)
                        {
                            for (int num139 = 0; num139 < 3; num139++)
                            {
                                int num140 = num139 * 5;
                                int num141 = num140 + 15;
                                float num142 = Utils.Remap(rCurrentNPC.ai[1], num140, num141, 0f, 1f);
                                if (num142 != 0f)
                                {
                                    float num143 = Utils.Remap(num142, 0f, 1f, 2f, 1.1f + 0.1f * (float)num139);
                                    float num144 = num142;
                                    mySpriteBatch.Draw(color: new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num144, texture: value51, position: vector54, sourceRectangle: frame6, rotation: rCurrentNPC.rotation, origin: halfSize, scale: rCurrentNPC.scale * num143, effects: spriteEffects, layerDepth: 0f);
                                }
                            }
                        }
                        if (rCurrentNPC.ai[0] == 2f)
                        {
                            Microsoft.Xna.Framework.Color color26 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * Utils.Remap(rCurrentNPC.ai[1], 0f, 30f, 1f, 0f);
                            for (int num145 = 0; num145 < 3; num145++)
                            {
                                float num146 = 1f;
                                Vector2 position20 = vector54 + rCurrentNPC.velocity * num145 * -2f;
                                float num147 = Utils.Remap(num145, 0f, 3f, 1f, 0f);
                                mySpriteBatch.Draw(value51, position20, frame6, color26 * num147, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale * num146, spriteEffects, 0f);
                            }
                            for (int num148 = 0; num148 < 3; num148++)
                            {
                                float num149 = 1.1f + 0.1f * (float)num148;
                                mySpriteBatch.Draw(value51, vector54, frame6, color26, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale * num149, spriteEffects, 0f);
                            }
                        }
                    }
                    if (type >= 639 && type <= 645)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[286].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.White), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    if (type >= 646 && type <= 652)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[287].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, rCurrentNPC.GetAlpha(Microsoft.Xna.Framework.Color.White), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    if (type >= 134 && type <= 136 && npcColor != Microsoft.Xna.Framework.Color.Black)
                    {
                        mySpriteBatch.Draw(TextureAssets.Dest[type - 134].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * (1f - (float)rCurrentNPC.alpha / 255f), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 125)
                    {
                        mySpriteBatch.Draw(TextureAssets.EyeLaser.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 139)
                    {
                        mySpriteBatch.Draw(TextureAssets.Probe.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 127)
                    {
                        if (NPC.IsMechQueenUp)
                        {
                            rCurrentNPC.whoAmI = rCurrentNPC.whoAmI;
                            for (int num150 = 0; num150 < 200; num150++)
                            {
                                if (!npc[num150].active || (npc[num150].type != 125 && npc[num150].type != 126))
                                {
                                    continue;
                                }
                                float scale5 = npc[num150].scale;
                                float x = npc[num150].Center.X;
                                float y2 = npc[num150].Center.Y;
                                Vector2 mechQueenCenter = rCurrentNPC.GetMechQueenCenter();
                                Vector2 vector55 = new Vector2((npc[num150].type == 125) ? (-18) : 20, -18f);
                                vector55 = vector55.RotatedBy(rCurrentNPC.rotation);
                                Vector2 vector56 = mechQueenCenter + vector55;
                                float num151 = x - vector56.X;
                                float num152 = y2 - vector56.Y;
                                float rotation9 = (float)Math.Atan2(num152, num151) - 1.57f;
                                bool flag11 = true;
                                float num153 = (float)Math.Sqrt(num151 * num151 + num152 * num152);
                                if (num153 > 2000f)
                                {
                                    flag11 = false;
                                }
                                float num154 = 40f * scale5;
                                while (flag11)
                                {
                                    num153 = (float)Math.Sqrt(num151 * num151 + num152 * num152);
                                    if (num153 < num154)
                                    {
                                        flag11 = false;
                                        continue;
                                    }
                                    num153 = (float)TextureAssets.Chain12.Height() * scale5 / num153;
                                    num151 *= num153;
                                    num152 *= num153;
                                    Microsoft.Xna.Framework.Color color27 = Lighting.GetColor((int)vector56.X / 16, (int)(vector56.Y / 16f));
                                    spriteBatch.Draw(TextureAssets.Chain12.Value, new Vector2(vector56.X - screenPosition.X, vector56.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain12.Width(), TextureAssets.Chain12.Height()), color27, rotation9, new Vector2((float)TextureAssets.Chain12.Width() * 0.5f, 0f), scale5, SpriteEffects.None, 0f);
                                    vector56.X += num151;
                                    vector56.Y += num152;
                                    num151 = x - vector56.X;
                                    num152 = y2 - vector56.Y;
                                }
                            }
                        }
                        else
                        {
                            mySpriteBatch.Draw(TextureAssets.BoneEyes.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 131)
                    {
                        mySpriteBatch.Draw(TextureAssets.BoneLaser.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 120)
                    {
                        for (int num155 = 1; num155 < rCurrentNPC.oldPos.Length; num155++)
                        {
                            _ = ref rCurrentNPC.oldPos[num155];
                            Microsoft.Xna.Framework.Color newColor3 = default(Microsoft.Xna.Framework.Color);
                            newColor3.R = (byte)(150 * (10 - num155) / 15);
                            newColor3.G = (byte)(100 * (10 - num155) / 15);
                            newColor3.B = (byte)(150 * (10 - num155) / 15);
                            newColor3.A = (byte)(50 * (10 - num155) / 15);
                            newColor3 = rCurrentNPC.GetShimmerColor(newColor3);
                            mySpriteBatch.Draw(TextureAssets.Chaos.Value, new Vector2(rCurrentNPC.oldPos[num155].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num155].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, newColor3, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 137 || type == 138)
                    {
                        for (int num156 = 1; num156 < rCurrentNPC.oldPos.Length; num156++)
                        {
                            _ = ref rCurrentNPC.oldPos[num156];
                            Microsoft.Xna.Framework.Color newColor4 = default(Microsoft.Xna.Framework.Color);
                            newColor4.R = (byte)(150 * (10 - num156) / 15);
                            newColor4.G = (byte)(100 * (10 - num156) / 15);
                            newColor4.B = (byte)(150 * (10 - num156) / 15);
                            newColor4.A = (byte)(50 * (10 - num156) / 15);
                            newColor4 = rCurrentNPC.GetShimmerColor(newColor4);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num156].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num156].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, newColor4, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 327)
                    {
                        mySpriteBatch.Draw(TextureAssets.PumpkingFace.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, Microsoft.Xna.Framework.Color.White, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        for (int num157 = 1; num157 < 10; num157++)
                        {
                            Microsoft.Xna.Framework.Color color28 = new Microsoft.Xna.Framework.Color(110 - num157 * 10, 110 - num157 * 10, 110 - num157 * 10, 110 - num157 * 10);
                            Vector2 vector57 = new Vector2((float)rand.Next(-10, 11) * 0.2f, (float)rand.Next(-10, 11) * 0.2f);
                            mySpriteBatch.Draw(TextureAssets.PumpkingFace.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36) + vector57, rCurrentNPC.frame, color28, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 325)
                    {
                        mySpriteBatch.Draw(TextureAssets.TreeFace.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, Microsoft.Xna.Framework.Color.White, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        for (int num158 = 1; num158 < 10; num158++)
                        {
                            Microsoft.Xna.Framework.Color color29 = new Microsoft.Xna.Framework.Color(110 - num158 * 10, 110 - num158 * 10, 110 - num158 * 10, 110 - num158 * 10);
                            Vector2 vector58 = new Vector2((float)rand.Next(-10, 11) * 0.2f, (float)rand.Next(-10, 11) * 0.2f);
                            mySpriteBatch.Draw(TextureAssets.TreeFace.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36) + vector58, rCurrentNPC.frame, color29, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 345)
                    {
                        mySpriteBatch.Draw(TextureAssets.IceQueen.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, Microsoft.Xna.Framework.Color.White, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        for (int num159 = 1; num159 < 5; num159++)
                        {
                            mySpriteBatch.Draw(color: new Microsoft.Xna.Framework.Color(100 - num159 * 10, 100 - num159 * 10, 100 - num159 * 10, 100 - num159 * 10), texture: TextureAssets.IceQueen.Value, position: new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36) - rCurrentNPC.velocity * num159 * 0.2f, sourceRectangle: rCurrentNPC.frame, rotation: rCurrentNPC.rotation, origin: halfSize, scale: rCurrentNPC.scale, effects: spriteEffects, layerDepth: 0f);
                        }
                    }
                    else if (type == 355)
                    {
                        mySpriteBatch.Draw(TextureAssets.Firefly.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 358)
                    {
                        mySpriteBatch.Draw(TextureAssets.Lightningbug.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 654)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[290].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 653)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[288].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 3f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 82)
                    {
                        mySpriteBatch.Draw(TextureAssets.WraithEye.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, Microsoft.Xna.Framework.Color.White, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        for (int num160 = 1; num160 < 10; num160++)
                        {
                            mySpriteBatch.Draw(color: new Microsoft.Xna.Framework.Color(110 - num160 * 10, 110 - num160 * 10, 110 - num160 * 10, 110 - num160 * 10), texture: TextureAssets.WraithEye.Value, position: new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36) - rCurrentNPC.velocity * num160 * 0.5f, sourceRectangle: rCurrentNPC.frame, rotation: rCurrentNPC.rotation, origin: halfSize, scale: rCurrentNPC.scale, effects: spriteEffects, layerDepth: 0f);
                        }
                    }
                    else if (type == 253)
                    {
                        mySpriteBatch.Draw(TextureAssets.ReaperEye.Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 3f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, Microsoft.Xna.Framework.Color.White, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        for (int num161 = 1; num161 < 20; num161++)
                        {
                            mySpriteBatch.Draw(color: new Microsoft.Xna.Framework.Color(210 - num161 * 20, 210 - num161 * 20, 210 - num161 * 20, 210 - num161 * 20), texture: TextureAssets.ReaperEye.Value, position: new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 3f + halfSize.Y * rCurrentNPC.scale + num36) - rCurrentNPC.velocity * num161 * 0.5f, sourceRectangle: rCurrentNPC.frame, rotation: rCurrentNPC.rotation, origin: halfSize, scale: rCurrentNPC.scale, effects: spriteEffects, layerDepth: 0f);
                        }
                    }
                    else if (type == 245 && rCurrentNPC.alpha == 0 && !getGoodWorld)
                    {
                        mySpriteBatch.Draw(color: new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, 0), texture: TextureAssets.Golem[3].Value, position: new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), sourceRectangle: frame6, rotation: rCurrentNPC.rotation, origin: halfSize, scale: rCurrentNPC.scale, effects: spriteEffects, layerDepth: 0f);
                    }
                    else if (type == 246 && !getGoodWorld)
                    {
                        Microsoft.Xna.Framework.Color color34 = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, 0);
                        if (rCurrentNPC.frame.Y < 222)
                        {
                            if (!getGoodWorld)
                            {
                                mySpriteBatch.Draw(TextureAssets.Golem[1].Value, new Vector2(rCurrentNPC.Center.X - screenPos.X - 20f, rCurrentNPC.Center.Y - screenPos.Y - 27f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Golem[1].Width(), TextureAssets.Golem[1].Height() / 2), color34, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                            }
                            Microsoft.Xna.Framework.Rectangle value52 = frame6;
                            value52.Y = 0;
                            mySpriteBatch.Draw(TextureAssets.Extra[107].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), value52, color34, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                        else if (!getGoodWorld && rCurrentNPC.frame.Y < 444)
                        {
                            mySpriteBatch.Draw(TextureAssets.Golem[2].Value, new Vector2(rCurrentNPC.Center.X - screenPos.X + 26f, rCurrentNPC.Center.Y - screenPos.Y - 28f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Golem[2].Width(), TextureAssets.Golem[2].Height() / 4), color34, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        }
                        else if (!getGoodWorld)
                        {
                            mySpriteBatch.Draw(TextureAssets.Golem[2].Value, new Vector2(rCurrentNPC.Center.X - screenPos.X - 38f, rCurrentNPC.Center.Y - screenPos.Y - 28f), new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.Golem[2].Height() / 2, TextureAssets.Golem[2].Width(), TextureAssets.Golem[2].Height() / 4), color34, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        }
                    }
                    else if (type == 249 && !getGoodWorld)
                    {
                        Microsoft.Xna.Framework.Color color35 = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, 0);
                        if (!getGoodWorld)
                        {
                            mySpriteBatch.Draw(TextureAssets.Golem[1].Value, new Vector2(rCurrentNPC.Center.X - screenPos.X - 20f, rCurrentNPC.Center.Y - screenPos.Y - 47f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Golem[1].Width(), TextureAssets.Golem[1].Height() / 2), color35, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        }
                        int num162 = (int)rCurrentNPC.frameCounter / 4;
                        Texture2D value53 = TextureAssets.Extra[106].Value;
                        Microsoft.Xna.Framework.Rectangle value54 = value53.Frame(1, 8);
                        _ = Microsoft.Xna.Framework.Color.White;
                        value54.Y += value54.Height * 2 * num162 + frame6.Y;
                        mySpriteBatch.Draw(value53, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), value54, color35, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        value53 = TextureAssets.Extra[107].Value;
                        value54 = frame6;
                        mySpriteBatch.Draw(value53, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), value54, color35, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 383)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[11].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        if (rCurrentNPC.ai[2] != 0f && npc[(int)rCurrentNPC.ai[2] - 1].active && npc[(int)rCurrentNPC.ai[2] - 1].type == 384)
                        {
                            _ = rCurrentNPC.ai[2];
                            mySpriteBatch.Draw(TextureAssets.Npc[384].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), null, new Microsoft.Xna.Framework.Color(100, 100, 100, 0), rCurrentNPC.rotation, new Vector2(TextureAssets.Npc[384].Width(), TextureAssets.Npc[384].Height()) / 2f, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 381)
                    {
                        Vector2 zero3 = Vector2.Zero;
                        Vector2 origin19 = Vector2.Zero;
                        int num163 = TextureAssets.Npc[type].Height() / npcFrameCount[type];
                        int num164 = rCurrentNPC.frame.Y / num163;
                        Microsoft.Xna.Framework.Rectangle value55 = new Microsoft.Xna.Framework.Rectangle(0, 0, 32, 42);
                        switch (num164)
                        {
                        case 0:
                            zero3 += new Vector2(8f, 32f);
                            break;
                        case 1:
                            zero3 += new Vector2(6f, 72f);
                            break;
                        case 2:
                            zero3 += new Vector2(8f, 126f);
                            break;
                        case 3:
                            zero3 += new Vector2(6f, 174f);
                            break;
                        case 4:
                            zero3 += new Vector2(6f, 224f);
                            break;
                        case 5:
                            zero3 += new Vector2(8f, 272f);
                            break;
                        case 6:
                            zero3 += new Vector2(10f, 318f);
                            break;
                        case 7:
                            zero3 += new Vector2(14f, 366f);
                            break;
                        case 8:
                            zero3 += new Vector2(10f, 414f);
                            break;
                        }
                        zero3.Y -= num163 * num164;
                        zero3 -= halfSize;
                        int num165 = 2;
                        if (rCurrentNPC.ai[2] > 0f)
                        {
                            num165 = (int)rCurrentNPC.ai[2] - 1;
                        }
                        if (rCurrentNPC.velocity.Y != 0f)
                        {
                            num165 = 3;
                        }
                        value55.Y += 44 * num165;
                        switch (num165)
                        {
                        case 0:
                            origin19 = new Vector2(10f, 18f);
                            break;
                        case 1:
                            origin19 = new Vector2(8f, 20f);
                            break;
                        case 2:
                            origin19 = new Vector2(8f, 20f);
                            break;
                        case 3:
                            origin19 = new Vector2(8f, 20f);
                            break;
                        case 4:
                            origin19 = new Vector2(6f, 18f);
                            break;
                        }
                        if (spriteEffects.HasFlag(SpriteEffects.FlipHorizontally))
                        {
                            zero3.X *= -1f;
                            origin19.X = (float)value55.Width - origin19.X;
                        }
                        zero3 += rCurrentNPC.Center;
                        zero3 -= screenPos;
                        zero3.Y += rCurrentNPC.gfxOffY;
                        mySpriteBatch.Draw(TextureAssets.Extra[0].Value, zero3, value55, npcColor, rCurrentNPC.rotation, origin19, rCurrentNPC.scale, spriteEffects, 0f);
                        mySpriteBatch.Draw(TextureAssets.GlowMask[24].Value, zero3, value55, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, origin19, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 382)
                    {
                        Vector2 zero4 = Vector2.Zero;
                        Vector2 origin20 = Vector2.Zero;
                        int num166 = TextureAssets.Npc[type].Height() / npcFrameCount[type];
                        int num167 = rCurrentNPC.frame.Y / num166;
                        Microsoft.Xna.Framework.Rectangle value56 = new Microsoft.Xna.Framework.Rectangle(0, 0, 30, 42);
                        switch (num167)
                        {
                        case 0:
                            zero4 += new Vector2(8f, 30f);
                            break;
                        case 1:
                            zero4 += new Vector2(6f, 68f);
                            break;
                        case 2:
                            zero4 += new Vector2(8f, 120f);
                            break;
                        case 3:
                            zero4 += new Vector2(6f, 166f);
                            break;
                        case 4:
                            zero4 += new Vector2(6f, 214f);
                            break;
                        case 5:
                            zero4 += new Vector2(8f, 260f);
                            break;
                        case 6:
                            zero4 += new Vector2(14f, 304f);
                            break;
                        case 7:
                            zero4 += new Vector2(14f, 350f);
                            break;
                        case 8:
                            zero4 += new Vector2(10f, 396f);
                            break;
                        }
                        zero4.Y -= num166 * num167;
                        zero4 -= halfSize;
                        int num168 = 2;
                        if (rCurrentNPC.ai[2] > 0f)
                        {
                            num168 = (int)rCurrentNPC.ai[2] - 1;
                        }
                        if (rCurrentNPC.velocity.Y != 0f)
                        {
                            num168 = 3;
                        }
                        value56.Y += 44 * num168;
                        switch (num168)
                        {
                        case 0:
                            origin20 = new Vector2(10f, 18f);
                            break;
                        case 1:
                            origin20 = new Vector2(8f, 20f);
                            break;
                        case 2:
                            origin20 = new Vector2(8f, 20f);
                            break;
                        case 3:
                            origin20 = new Vector2(8f, 20f);
                            break;
                        case 4:
                            origin20 = new Vector2(6f, 18f);
                            break;
                        }
                        if (spriteEffects.HasFlag(SpriteEffects.FlipHorizontally))
                        {
                            zero4.X *= -1f;
                            origin20.X = (float)value56.Width - origin20.X;
                        }
                        zero4 += rCurrentNPC.Center;
                        zero4 -= screenPos;
                        zero4.Y += rCurrentNPC.gfxOffY;
                        mySpriteBatch.Draw(TextureAssets.Extra[1].Value, zero4, value56, npcColor, rCurrentNPC.rotation, origin20, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 520)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[164].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        Vector2 zero5 = Vector2.Zero;
                        Vector2 origin21 = new Vector2(4f, 4f);
                        int num169 = TextureAssets.Npc[type].Height() / npcFrameCount[type];
                        _ = rCurrentNPC.frame.Y / num169;
                        if (spriteEffects.HasFlag(SpriteEffects.FlipHorizontally))
                        {
                            zero5.X *= -1f;
                            origin21.X = (float)TextureAssets.Extra[56].Width() - origin21.X;
                        }
                        zero5 += rCurrentNPC.Top + new Vector2(0f, 20f);
                        zero5 -= screenPos;
                        zero5.Y += rCurrentNPC.gfxOffY;
                        float num170 = rCurrentNPC.localAI[3];
                        if (spriteEffects.HasFlag(SpriteEffects.FlipHorizontally))
                        {
                            num170 += (float)Math.PI;
                        }
                        mySpriteBatch.Draw(TextureAssets.Extra[56].Value, zero5, null, npcColor, num170, origin21, rCurrentNPC.scale, spriteEffects, 0f);
                        mySpriteBatch.Draw(TextureAssets.GlowMask[165].Value, zero5, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), num170, origin21, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 386)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[31].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 387)
                    {
                        Microsoft.Xna.Framework.Color color36 = new Microsoft.Xna.Framework.Color(1f, 1f, 1f, 1f) * 0.75f;
                        if (rCurrentNPC.ai[0] > 0f)
                        {
                            float amount7 = (rCurrentNPC.ai[0] + 1f) / 60f;
                            color36 = Microsoft.Xna.Framework.Color.Lerp(color36, Microsoft.Xna.Framework.Color.White, amount7);
                            color36.A = (byte)MathHelper.Lerp((int)color36.A, 0f, amount7);
                        }
                        color36 *= (255f - (float)rCurrentNPC.alpha) / 255f;
                        mySpriteBatch.Draw(TextureAssets.GlowMask[32].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, color36, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 388)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[33].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 389)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[34].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 4 && rCurrentNPC.ai[1] >= 4f && rCurrentNPC.ai[0] == 3f)
                    {
                        for (int num171 = 1; num171 < rCurrentNPC.oldPos.Length; num171++)
                        {
                            _ = ref rCurrentNPC.oldPos[num171];
                            Microsoft.Xna.Framework.Color color37 = npcColor;
                            color37.R = (byte)(0.5 * (double)(int)color37.R * (double)(10 - num171) / 20.0);
                            color37.G = (byte)(0.5 * (double)(int)color37.G * (double)(10 - num171) / 20.0);
                            color37.B = (byte)(0.5 * (double)(int)color37.B * (double)(10 - num171) / 20.0);
                            color37.A = (byte)(0.5 * (double)(int)color37.A * (double)(10 - num171) / 20.0);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num171].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num171].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, color37, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 437)
                    {
                        Microsoft.Xna.Framework.Color white5 = Microsoft.Xna.Framework.Color.White;
                        white5.A = 200;
                        mySpriteBatch.Draw(TextureAssets.GlowMask[109].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), frame6, white5, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        mySpriteBatch.Draw(TextureAssets.GlowMask[108].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + num35 + rCurrentNPC.gfxOffY), null, white5, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (type == 471 && rCurrentNPC.ai[3] < 0f)
                    {
                        for (int num172 = 1; num172 < rCurrentNPC.oldPos.Length; num172++)
                        {
                            _ = ref rCurrentNPC.oldPos[num172];
                            Microsoft.Xna.Framework.Color color38 = npcColor;
                            color38.R = (byte)(0.5 * (double)(int)color38.R * (double)(10 - num172) / 20.0);
                            color38.G = (byte)(0.5 * (double)(int)color38.G * (double)(10 - num172) / 20.0);
                            color38.B = (byte)(0.5 * (double)(int)color38.B * (double)(10 - num172) / 20.0);
                            color38.A = (byte)(0.5 * (double)(int)color38.A * (double)(10 - num172) / 20.0);
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num172].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num172].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, color38, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 477 && rCurrentNPC.velocity.Length() > 9f)
                    {
                        for (int num173 = 1; num173 < rCurrentNPC.oldPos.Length; num173++)
                        {
                            _ = ref rCurrentNPC.oldPos[num173];
                            Microsoft.Xna.Framework.Color color39 = npcColor;
                            color39.R = (byte)(0.5 * (double)(int)color39.R * (double)(10 - num173) / 20.0);
                            color39.G = (byte)(0.5 * (double)(int)color39.G * (double)(10 - num173) / 20.0);
                            color39.B = (byte)(0.5 * (double)(int)color39.B * (double)(10 - num173) / 20.0);
                            color39.A = (byte)(0.5 * (double)(int)color39.A * (double)(10 - num173) / 20.0);
                            Microsoft.Xna.Framework.Rectangle frame7 = rCurrentNPC.frame;
                            int num174 = TextureAssets.Npc[type].Height() / npcFrameCount[type];
                            frame7.Y -= num174 * num173;
                            while (frame7.Y < 0)
                            {
                                frame7.Y += num174 * npcFrameCount[type];
                            }
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num173].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num173].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), frame7, color39, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    if (type == 479 && (double)rCurrentNPC.velocity.Length() > 6.5)
                    {
                        for (int num175 = 1; num175 < rCurrentNPC.oldPos.Length; num175++)
                        {
                            _ = ref rCurrentNPC.oldPos[num175];
                            Microsoft.Xna.Framework.Color color40 = npcColor;
                            color40.R = (byte)(0.5 * (double)(int)color40.R * (double)(10 - num175) / 20.0);
                            color40.G = (byte)(0.5 * (double)(int)color40.G * (double)(10 - num175) / 20.0);
                            color40.B = (byte)(0.5 * (double)(int)color40.B * (double)(10 - num175) / 20.0);
                            color40.A = (byte)(0.5 * (double)(int)color40.A * (double)(10 - num175) / 20.0);
                            Microsoft.Xna.Framework.Rectangle frame8 = rCurrentNPC.frame;
                            int num176 = TextureAssets.Npc[type].Height() / npcFrameCount[type];
                            frame8.Y -= num176 * num175;
                            while (frame8.Y < 0)
                            {
                                frame8.Y += num176 * npcFrameCount[type];
                            }
                            mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num175].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num175].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), frame8, color40, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                        }
                    }
                    else if (type == 472)
                    {
                        mySpriteBatch.Draw(TextureAssets.GlowMask[110].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                    }
                    else if (rCurrentNPC.aiStyle == 87)
                    {
                        if ((int)rCurrentNPC.ai[0] == 4 || rCurrentNPC.ai[0] == 5f || rCurrentNPC.ai[0] == 6f)
                        {
                            for (int num177 = 1; num177 < rCurrentNPC.oldPos.Length; num177++)
                            {
                                _ = ref rCurrentNPC.oldPos[num177];
                                Microsoft.Xna.Framework.Color newColor5 = npcColor;
                                newColor5.R = (byte)(0.5 * (double)(int)newColor5.R * (double)(10 - num177) / 20.0);
                                newColor5.G = (byte)(0.5 * (double)(int)newColor5.G * (double)(10 - num177) / 20.0);
                                newColor5.B = (byte)(0.5 * (double)(int)newColor5.B * (double)(10 - num177) / 20.0);
                                newColor5.A = (byte)(0.5 * (double)(int)newColor5.A * (double)(10 - num177) / 20.0);
                                newColor5 = rCurrentNPC.GetShimmerColor(newColor5);
                                mySpriteBatch.Draw(TextureAssets.Npc[type].Value, new Vector2(rCurrentNPC.oldPos[num177].X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[type].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.oldPos[num177].Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[type].Height() * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36), rCurrentNPC.frame, newColor5, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            }
                        }
                    }
                    else
                    {
                        switch (type)
                        {
                        case 50:
                        {
                            Texture2D value57 = TextureAssets.Extra[39].Value;
                            Vector2 center4 = rCurrentNPC.Center;
                            float num199 = 0f;
                            switch (rCurrentNPC.frame.Y / (TextureAssets.Npc[type].Height() / npcFrameCount[type]))
                            {
                            case 0:
                                num199 = 2f;
                                break;
                            case 1:
                                num199 = -6f;
                                break;
                            case 2:
                                num199 = 2f;
                                break;
                            case 3:
                                num199 = 10f;
                                break;
                            case 4:
                                num199 = 2f;
                                break;
                            case 5:
                                num199 = 0f;
                                break;
                            }
                            center4.Y += rCurrentNPC.gfxOffY - (70f - num199) * rCurrentNPC.scale;
                            mySpriteBatch.Draw(value57, center4 - screenPos, null, npcColor, 0f, value57.Size() / 2f, 1f, spriteEffects, 0f);
                            break;
                        }
                        case 411:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[136].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 409:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[138].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 410:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[137].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 407:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[139].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 405:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[141].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 406:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[142].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 424:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[144].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 423:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[145].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 421:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[146].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 420:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[147].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 425:
                        {
                            Vector2 vector60 = rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY);
                            mySpriteBatch.Draw(TextureAssets.GlowMask[150].Value, vector60, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            Vector2 drawpos = vector60 + new Vector2(27 * -rCurrentNPC.spriteDirection, 0f);
                            float num200 = rCurrentNPC.ai[3];
                            DrawPrettyStarSparkle(Utils.Remap(num200, 0f, 15f, 0f, 1f), SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), Microsoft.Xna.Framework.Color.Green, num200, 0f, 30f, 30f, 36f, 0f, new Vector2(3f, 1.5f), new Vector2(2f, 2f));
                            break;
                        }
                        case 429:
                            mySpriteBatch.Draw(TextureAssets.GlowMask[151].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        case 418:
                        {
                            mySpriteBatch.Draw(TextureAssets.GlowMask[161].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            float num197 = 0.25f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.25f;
                            for (int num198 = 0; num198 < 4; num198++)
                            {
                                mySpriteBatch.Draw(TextureAssets.GlowMask[161].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + rCurrentNPC.velocity.RotatedBy((float)num198 * ((float)Math.PI / 2f)) * num197, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            }
                            break;
                        }
                        case 412:
                        case 413:
                        case 414:
                        {
                            Microsoft.Xna.Framework.Color color41 = new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 0);
                            int num194 = 157 + type - 412;
                            if (type == 414 && rCurrentNPC.localAI[2] != 0f)
                            {
                                int num195 = (int)rCurrentNPC.localAI[2];
                                if (rCurrentNPC.localAI[2] < 0f)
                                {
                                    num195 = 128 + (int)rCurrentNPC.localAI[2];
                                }
                                int num196 = 255 - num195;
                                color41 = new Microsoft.Xna.Framework.Color(num196, num195, num195, num196);
                            }
                            mySpriteBatch.Draw(TextureAssets.GlowMask[num194].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, color41, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                            break;
                        }
                        default:
                            switch (type)
                            {
                            case 415:
                            {
                                mySpriteBatch.Draw(TextureAssets.GlowMask[155].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                float num178 = 0.5f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.5f;
                                for (int num179 = 0; num179 < 4; num179++)
                                {
                                    mySpriteBatch.Draw(TextureAssets.GlowMask[155].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + rCurrentNPC.velocity.RotatedBy((float)num179 * ((float)Math.PI / 2f)) * num178, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                                break;
                            }
                            case 419:
                                mySpriteBatch.Draw(TextureAssets.GlowMask[154].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                if (rCurrentNPC.ai[2] >= -6f)
                                {
                                    float num182 = 0.5f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.5f;
                                    for (int num183 = 0; num183 < 4; num183++)
                                    {
                                        mySpriteBatch.Draw(TextureAssets.GlowMask[154].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + rCurrentNPC.velocity.RotatedBy((float)num183 * ((float)Math.PI / 2f)) * num182, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                    }
                                }
                                else
                                {
                                    float num184 = 4f;
                                    for (int num185 = 0; num185 < 4; num185++)
                                    {
                                        mySpriteBatch.Draw(TextureAssets.GlowMask[154].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + Vector2.UnitX.RotatedBy((float)num185 * ((float)Math.PI / 2f)) * num184, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                    }
                                }
                                break;
                            case 417:
                            {
                                mySpriteBatch.Draw(TextureAssets.GlowMask[160].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                float num192 = 0.25f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.25f;
                                for (int num193 = 0; num193 < 4; num193++)
                                {
                                    mySpriteBatch.Draw(TextureAssets.GlowMask[160].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + rCurrentNPC.velocity.RotatedBy((float)num193 * ((float)Math.PI / 2f)) * num192, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                                break;
                            }
                            case 516:
                            {
                                mySpriteBatch.Draw(TextureAssets.Npc[type].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                float num186 = 0.5f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.5f;
                                for (int num187 = 0; num187 < 4; num187++)
                                {
                                    mySpriteBatch.Draw(TextureAssets.Npc[type].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + rCurrentNPC.velocity.RotatedBy((float)num187 * ((float)Math.PI / 2f)) * num186, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                                break;
                            }
                            case 518:
                            {
                                Vector2 vector59 = new Vector2(-10f, 0f);
                                mySpriteBatch.Draw(TextureAssets.GlowMask[163].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha), rCurrentNPC.rotation, halfSize + vector59, rCurrentNPC.scale, spriteEffects, 0f);
                                float num190 = 0.5f + (rCurrentNPC.GetAlpha(npcColor).ToVector3() - new Vector3(0.5f)).Length() * 0.5f;
                                for (int num191 = 0; num191 < 4; num191++)
                                {
                                    mySpriteBatch.Draw(TextureAssets.GlowMask[163].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + rCurrentNPC.velocity.RotatedBy((float)num191 * ((float)Math.PI / 2f)) * num190, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize + vector59, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                                break;
                            }
                            case 344:
                                mySpriteBatch.Draw(TextureAssets.GlowMask[253].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 100) * 0.5f, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            case 346:
                            {
                                float num180 = 4f;
                                for (int num181 = 0; num181 < 4; num181++)
                                {
                                    mySpriteBatch.Draw(TextureAssets.GlowMask[254].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + Vector2.UnitX.RotatedBy((float)num181 * ((float)Math.PI / 2f)) * num180, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                                mySpriteBatch.Draw(TextureAssets.GlowMask[254].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 100), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            }
                            case 315:
                            {
                                float num188 = 2f;
                                for (int num189 = 0; num189 < 4; num189++)
                                {
                                    mySpriteBatch.Draw(TextureAssets.GlowMask[255].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY) + Vector2.UnitX.RotatedBy((float)num189 * ((float)Math.PI / 2f)) * num188, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(64, 64, 64, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                }
                                mySpriteBatch.Draw(TextureAssets.GlowMask[255].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 200), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            }
                            case 525:
                                mySpriteBatch.Draw(TextureAssets.GlowMask[169].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 100), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            case 526:
                                mySpriteBatch.Draw(TextureAssets.GlowMask[170].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 100), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            case 527:
                                mySpriteBatch.Draw(TextureAssets.GlowMask[171].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(200, 200, 200, 100), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            case 533:
                                mySpriteBatch.Draw(TextureAssets.GlowMask[172].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 100), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            case 160:
                            {
                                Texture2D texture2D2 = null;
                                texture2D2 = ((rCurrentNPC.townNpcVariationIndex != 1) ? TextureAssets.GlowMask[166].Value : TextureAssets.GlowMask[352].Value);
                                mySpriteBatch.Draw(texture2D2, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            }
                            case 209:
                            {
                                Texture2D texture2D = null;
                                texture2D = ((rCurrentNPC.townNpcVariationIndex != 1) ? TextureAssets.GlowMask[167].Value : ((rCurrentNPC.altTexture != 1) ? TextureAssets.GlowMask[350].Value : TextureAssets.GlowMask[351].Value));
                                mySpriteBatch.Draw(texture2D, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                                break;
                            }
                            }
                            break;
                        }
                    }
                    if (rCurrentNPC.aiStyle == 7)
                    {
                        DrawNPCExtras(rCurrentNPC, beforeDraw: false, num36, num35, npcColor, halfSize, spriteEffects, screenPos);
                    }
                    break;
                }
                case 488:
                    break;
                }
                break;
            }
            goto case 426;
        case 426:
        case 427:
        case 428:
        case 521:
        case 523:
        case 541:
        case 542:
        case 543:
        case 544:
        case 545:
        case 581:
        {
            Texture2D value76 = TextureAssets.Npc[type].Value;
            Microsoft.Xna.Framework.Color color46 = Microsoft.Xna.Framework.Color.White;
            float amount10 = 0f;
            float amount11 = 0f;
            int num270 = 0;
            int num271 = 0;
            int num272 = 1;
            int num273 = 15;
            int num274 = 0;
            float scale8 = rCurrentNPC.scale;
            float value77 = rCurrentNPC.scale;
            int num275 = 0;
            float num276 = 0f;
            float num277 = 0f;
            float num278 = 0f;
            Microsoft.Xna.Framework.Color color47 = npcColor;
            Vector2 origin23 = halfSize;
            switch (type)
            {
            case 558:
            case 559:
            case 560:
            case 574:
            case 575:
                if (rCurrentNPC.ai[0] != 2f)
                {
                    num270 = 0;
                    break;
                }
                num270 = 6;
                num271 = 2;
                num273 = num270 * 3;
                num274 = 1;
                break;
            case 566:
            case 567:
            case 578:
                num270 = 0;
                num36 = -2f;
                break;
            case 552:
            case 553:
            case 554:
            case 555:
            case 556:
            case 557:
            case 561:
            case 562:
            case 563:
            case 568:
            case 569:
            case 570:
            case 571:
            case 572:
            case 573:
                num270 = 0;
                if (type == 561 || type == 562 || type == 563)
                {
                    num36 = -8f;
                }
                if (type == 555 || type == 556 || type == 557)
                {
                    num36 = -5f;
                }
                if (type == 572 || type == 573)
                {
                    num36 = -4f;
                }
                if (type == 570 || type == 571)
                {
                    spriteEffects ^= SpriteEffects.FlipHorizontally;
                    num36 = -2f;
                }
                if (type == 568 || type == 569)
                {
                    spriteEffects ^= SpriteEffects.FlipHorizontally;
                    num36 = -3f;
                    num275 = 4;
                    num277 = 4f;
                    num276 = (float)Math.Cos(GlobalTimeWrappedHourly % 1.5f / 1.5f * ((float)Math.PI * 2f)) / 6f + 0.75f;
                    color46 = Microsoft.Xna.Framework.Color.HotPink;
                    color46.A = 127;
                    amount10 = 0.5f;
                }
                if (rCurrentNPC.localAI[3] < 60f)
                {
                    float num291 = rCurrentNPC.localAI[3] / 60f;
                    num275 = 3;
                    num276 = 1f - num291 * num291;
                    num277 = 8f;
                    color46 = new Microsoft.Xna.Framework.Color(127, 0, 255, 0);
                    amount11 = 1f;
                    color47 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color47, num291 * num291);
                }
                break;
            case 541:
                num275 = 4;
                num277 = 6f;
                num276 = (float)Math.Cos(GlobalTimeWrappedHourly % 2.4f / 2.4f * ((float)Math.PI * 2f)) / 2f + 0.5f;
                color46 = Microsoft.Xna.Framework.Color.Gold;
                amount10 = 0.5f;
                break;
            case 661:
                num275 = 6;
                num277 = 6f;
                num276 = (float)Math.Cos(GlobalTimeWrappedHourly % 2.4f / 2.4f * ((float)Math.PI * 2f)) / 2f + 0.5f;
                num276 = MathHelper.Max(num276, Utils.GetLerpValue(0f, 60f, rCurrentNPC.ai[2], clamped: true));
                amount10 = 0.5f;
                break;
            case 426:
                num275 = 4;
                num277 = 4f;
                num276 = (float)Math.Cos(GlobalTimeWrappedHourly % 1.2f / 1.2f * ((float)Math.PI * 2f)) / 2f + 0.5f;
                color46 = Microsoft.Xna.Framework.Color.Turquoise;
                amount10 = 0.5f;
                num270 = 6;
                num271 = 2;
                num273 = num270;
                break;
            case 427:
                num270 = 8;
                num271 = 2;
                num273 = num270 * 3;
                break;
            case 546:
                num270 = 8;
                num271 = 2;
                num273 = num270 * 3;
                break;
            case 542:
            case 543:
            case 544:
            case 545:
                num270 = 6;
                num271 = 3;
                num273 = num270 * 2;
                break;
            case 581:
                num270 = 6;
                num271 = 2;
                num273 = num270 * 3;
                break;
            case 521:
                num270 = 10;
                num271 = 2;
                num273 = num270;
                num274 = 1;
                value77 = 0.3f;
                break;
            case 523:
                num275 = 3;
                num277 = 10f * rCurrentNPC.scale;
                amount10 = 0.5f;
                amount11 = 0.8f;
                color46 = Microsoft.Xna.Framework.Color.HotPink;
                color46.A = 128;
                num278 = rCurrentNPC.localAI[0];
                num276 = rCurrentNPC.localAI[1];
                break;
            case 620:
                num36 = -9f;
                origin23 = rCurrentNPC.frame.Size() * new Vector2(0.5f, 0.5f) + new Vector2(-4 * rCurrentNPC.spriteDirection, 0f);
                num275 = 4;
                num277 = 6f;
                num276 = (float)Math.Cos(GlobalTimeWrappedHourly % 2.4f / 2.4f * ((float)Math.PI * 2f)) / 2f + 0.5f;
                color46 = Microsoft.Xna.Framework.Color.Gold;
                amount10 = 0.5f;
                num270 = 6;
                num271 = 2;
                num273 = num270 * 3;
                num274 = 1;
                break;
            case 618:
            {
                float num279 = 90f;
                float num280 = 180f;
                if (rCurrentNPC.ai[0] == 1f && rCurrentNPC.ai[1] < num279)
                {
                    int num281 = 3;
                    float num282 = num279 / (float)num281;
                    float num283 = rCurrentNPC.ai[1] % num282 / num282;
                    num275 = 6;
                    num277 = 15f;
                    num276 = num283 * 0.8f + 0.2f;
                }
                if (rCurrentNPC.ai[0] == 3f && rCurrentNPC.ai[1] < num280)
                {
                    int num284 = 1;
                    float num285 = num280 / (float)num284;
                    float num286 = rCurrentNPC.ai[1] % num285 / num285;
                    num275 = 4;
                    num277 = 25f;
                    num276 = num286;
                    Vector2 vector69 = rCurrentNPC.scale * new Vector2(1f, 0.5f + num286 * 0.75f);
                    Texture2D value78 = TextureAssets.Extra[59].Value;
                    Microsoft.Xna.Framework.Rectangle rectangle12 = value78.Frame();
                    Vector2 origin24 = rectangle12.Size() * new Vector2(0.5f, 0.5f);
                    for (int num287 = 0; num287 < num275; num287++)
                    {
                        Microsoft.Xna.Framework.Color white8 = Microsoft.Xna.Framework.Color.White;
                        white8 *= Utils.GetLerpValue(0f, 0.5f, num276) * Utils.GetLerpValue(1f, 0.5f, num276) * 0.25f;
                        white8.A = 0;
                        white8.G = 0;
                        white8.B = 0;
                        float num288 = (float)num287 / (float)num275 * ((float)Math.PI * 2f) + rCurrentNPC.rotation + num278;
                        Vector2 position30 = rCurrentNPC.Center + num288.ToRotationVector2() * num277 * num276 - screenPos;
                        position30 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position30 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value78, position30, rectangle12, white8, num288, origin24, vector69 * 1.8f, spriteEffects, 0f);
                    }
                    for (int num289 = 0; num289 < num275; num289++)
                    {
                        Microsoft.Xna.Framework.Color white9 = Microsoft.Xna.Framework.Color.White;
                        white9 *= Utils.GetLerpValue(0f, 0.5f, num276) * Utils.GetLerpValue(1f, 0.5f, num276) * 0.25f;
                        white9.A = 0;
                        float num290 = (float)num289 / (float)num275 * ((float)Math.PI * 2f) + rCurrentNPC.rotation + num278;
                        Vector2 position31 = rCurrentNPC.Center + num290.ToRotationVector2() * num277 * num276 - screenPos;
                        position31 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                        position31 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                        mySpriteBatch.Draw(value78, position31, rectangle12, white9, num290, origin24, vector69 * 1.5f, spriteEffects, 0f);
                    }
                }
                break;
            }
            }
            for (int num292 = num272; num292 < num270; num292 += num271)
            {
                _ = ref rCurrentNPC.oldPos[num292];
                Microsoft.Xna.Framework.Color value79 = color47;
                value79 = Microsoft.Xna.Framework.Color.Lerp(value79, color46, amount10);
                value79 = rCurrentNPC.GetAlpha(value79);
                value79 *= (float)(num270 - num292) / (float)num273;
                _ = rCurrentNPC.rotation;
                if (num274 == 1)
                {
                    _ = rCurrentNPC.oldRot[num292];
                }
                float scale9 = MathHelper.Lerp(scale8, value77, 1f - (float)(num270 - num292) / (float)num273);
                Vector2 position32 = rCurrentNPC.oldPos[num292] + new Vector2(rCurrentNPC.width, rCurrentNPC.height) / 2f - screenPos;
                position32 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                position32 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                mySpriteBatch.Draw(value76, position32, rCurrentNPC.frame, value79, rCurrentNPC.rotation, halfSize, scale9, spriteEffects, 0f);
            }
            for (int num293 = 0; num293 < num275; num293++)
            {
                Microsoft.Xna.Framework.Color value80 = npcColor;
                value80 = Microsoft.Xna.Framework.Color.Lerp(value80, color46, amount10);
                value80 = rCurrentNPC.GetAlpha(value80);
                value80 = Microsoft.Xna.Framework.Color.Lerp(value80, color46, amount11);
                value80 *= 1f - num276;
                Vector2 position33 = rCurrentNPC.Center + ((float)num293 / (float)num275 * ((float)Math.PI * 2f) + rCurrentNPC.rotation + num278).ToRotationVector2() * num277 * num276 - screenPos;
                position33 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                position33 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                mySpriteBatch.Draw(value76, position33, rCurrentNPC.frame, value80, rCurrentNPC.rotation, origin23, rCurrentNPC.scale, spriteEffects, 0f);
            }
            Vector2 vector70 = rCurrentNPC.Center - screenPos;
            vector70 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
            vector70 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
            mySpriteBatch.Draw(value76, vector70, rCurrentNPC.frame, rCurrentNPC.GetAlpha(color47), rCurrentNPC.rotation, origin23, rCurrentNPC.scale, spriteEffects, 0f);
            switch (type)
            {
            case 427:
                mySpriteBatch.Draw(TextureAssets.GlowMask[152].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 255 - rCurrentNPC.alpha, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                break;
            case 426:
                mySpriteBatch.Draw(TextureAssets.GlowMask[153].Value, rCurrentNPC.Bottom - screenPos + new Vector2((float)(-TextureAssets.Npc[type].Width()) * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, (float)(-TextureAssets.Npc[type].Height()) * rCurrentNPC.scale / (float)npcFrameCount[type] + 4f + halfSize.Y * rCurrentNPC.scale + num36 + rCurrentNPC.gfxOffY), rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 128 - rCurrentNPC.alpha / 2, 0), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                break;
            }
            if (type == 541)
            {
                Microsoft.Xna.Framework.Color color48 = new Microsoft.Xna.Framework.Color(127 - rCurrentNPC.alpha, 127 - rCurrentNPC.alpha, 127 - rCurrentNPC.alpha, 0).MultiplyRGBA(Microsoft.Xna.Framework.Color.Gold);
                for (int num294 = 0; num294 < num275; num294++)
                {
                    Microsoft.Xna.Framework.Color newColor6 = color48;
                    newColor6 = rCurrentNPC.GetAlpha(newColor6);
                    newColor6 *= 1f - num276;
                    Vector2 position34 = rCurrentNPC.Center + ((float)num294 / (float)num275 * ((float)Math.PI * 2f) + rCurrentNPC.rotation + num278).ToRotationVector2() * (4f * num276 + 2f) - screenPos;
                    position34 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    position34 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(TextureAssets.GlowMask[216].Value, position34, rCurrentNPC.frame, newColor6, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                }
                mySpriteBatch.Draw(TextureAssets.GlowMask[216].Value, vector70, rCurrentNPC.frame, color48, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
            }
            if (type == 661)
            {
                num278 = MathHelper.Lerp(0f, 3f, Utils.GetLerpValue(0f, 60f, rCurrentNPC.ai[2], clamped: true));
                for (int num295 = 0; num295 < num275; num295++)
                {
                    Microsoft.Xna.Framework.Color newColor7 = new Microsoft.Xna.Framework.Color(127 - rCurrentNPC.alpha, 127 - rCurrentNPC.alpha, 127 - rCurrentNPC.alpha, 0).MultiplyRGBA(hslToRgb((GlobalTimeWrappedHourly + (float)num295 / (float)num275) % 1f, 1f, 0.5f));
                    newColor7 = rCurrentNPC.GetAlpha(newColor7);
                    newColor7 *= 1f - num276 * 0.5f;
                    newColor7.A = 0;
                    float num296 = 2f + rCurrentNPC.ai[2];
                    Vector2 position35 = rCurrentNPC.Center + ((float)num295 / (float)num275 * ((float)Math.PI * 2f) + rCurrentNPC.rotation + num278).ToRotationVector2() * (num296 * num276 + 2f) - screenPos;
                    position35 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    position35 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(value76, position35, rCurrentNPC.frame, newColor7, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                }
                mySpriteBatch.Draw(value76, vector70, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.1f, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
            }
            if ((type == 568 || type == 569) && rCurrentNPC.localAI[3] >= 60f)
            {
                Microsoft.Xna.Framework.Color color49 = new Microsoft.Xna.Framework.Color(127 - rCurrentNPC.alpha, 127 - rCurrentNPC.alpha, 127 - rCurrentNPC.alpha, 0).MultiplyRGBA(color46);
                for (int num297 = 0; num297 < num275; num297++)
                {
                    Microsoft.Xna.Framework.Color newColor8 = color49;
                    newColor8 = rCurrentNPC.GetAlpha(newColor8);
                    newColor8 *= 1f - num276;
                    Vector2 position36 = rCurrentNPC.Center + ((float)num297 / (float)num275 * ((float)Math.PI * 2f) + rCurrentNPC.rotation + num278).ToRotationVector2() * (4f * num276 + 2f) - screenPos;
                    position36 -= new Vector2(value76.Width, value76.Height / npcFrameCount[type]) * rCurrentNPC.scale / 2f;
                    position36 += halfSize * rCurrentNPC.scale + new Vector2(0f, num35 + num36 + rCurrentNPC.gfxOffY);
                    mySpriteBatch.Draw(TextureAssets.GlowMask[224].Value, position36, rCurrentNPC.frame, newColor8, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                }
                mySpriteBatch.Draw(TextureAssets.GlowMask[224].Value, vector70, rCurrentNPC.frame, color49, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
                float num298 = rCurrentNPC.localAI[0];
                if (num298 > 0f)
                {
                    byte a = (byte)((Math.Cos(num298 * ((float)Math.PI * 2f) / 60f) * 0.5 + 0.5) * 32.0 + 0.0);
                    Microsoft.Xna.Framework.Color color50 = new Microsoft.Xna.Framework.Color(180, 90, 255, a) * 0.75f;
                    float num299 = 1f;
                    if (num298 < 60f)
                    {
                        float lerpValue3 = Utils.GetLerpValue(0f, 60f, num298);
                        color50 *= lerpValue3;
                        num299 = MathHelper.Lerp(1f, 0.5f, 1f - lerpValue3 * lerpValue3);
                    }
                    Texture2D value81 = TextureAssets.Extra[89].Value;
                    Vector2 origin25 = value81.Size() / 2f;
                    Vector2 scale10 = new Vector2(num299);
                    float num300 = num298 * 0.0041887905f;
                    float num301 = (float)Math.PI / 2f;
                    scale10.Y *= 1f;
                    scale10.X *= 1f;
                    for (float num302 = 0f; num302 < 16f; num302 += 1f)
                    {
                        float num303 = num300 + (float)Math.PI * 2f * (num302 / 16f);
                        Vector2 position37 = rCurrentNPC.Center - screenPos + num303.ToRotationVector2() * 400f * num299;
                        mySpriteBatch.Draw(value81, position37, null, color50, num303 + (float)Math.PI / 2f + num301, origin25, scale10, SpriteEffects.None, 0f);
                    }
                }
            }
            if (type == 546)
            {
                mySpriteBatch.Draw(TextureAssets.Extra[76].Value, vector70, rCurrentNPC.frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 200), MathHelper.Clamp(rCurrentNPC.velocity.X * 0.1f, -(float)Math.PI / 8f, (float)Math.PI / 8f), halfSize, rCurrentNPC.scale, spriteEffects, 0f);
            }
            if ((type == 566 || type == 567) && rCurrentNPC.localAI[3] >= 115f)
            {
                int frameY = (int)(GlobalTimeWrappedHourly % 0.5f / 0.5f * 4f);
                Texture2D value82 = TextureAssets.Extra[80].Value;
                Microsoft.Xna.Framework.Rectangle rectangle13 = value82.Frame(1, 4, 0, frameY);
                Vector2 vector71 = new Vector2(rCurrentNPC.spriteDirection * 8, -26f) * rCurrentNPC.scale;
                int num304 = rCurrentNPC.frame.Y / rCurrentNPC.frame.Height;
                int num305 = 0;
                switch (num304)
                {
                case 0:
                    num305 = 6;
                    break;
                case 1:
                    num305 = 4;
                    break;
                case 2:
                    num305 = 2;
                    break;
                case 3:
                    num305 = 6;
                    break;
                case 4:
                    num305 = 8;
                    break;
                case 5:
                    num305 = 6;
                    break;
                case 6:
                    num305 = 4;
                    break;
                case 7:
                    num305 = 6;
                    break;
                case 8:
                    num305 = 2;
                    break;
                }
                Microsoft.Xna.Framework.Color color51 = new Microsoft.Xna.Framework.Color(255, 255, 255, 130);
                vector71.Y += num305;
                mySpriteBatch.Draw(value82, vector70 + vector71 * rCurrentNPC.scale, rectangle13, color51, MathHelper.Clamp(rCurrentNPC.velocity.X * 0.1f, -(float)Math.PI / 8f, (float)Math.PI / 8f), rectangle13.Size() / 2f, rCurrentNPC.scale * 0.7f, spriteEffects ^ SpriteEffects.FlipHorizontally, 0f);
            }
            if (type == 618)
            {
                mySpriteBatch.Draw(TextureAssets.Extra[129].Value, vector70, rCurrentNPC.frame, rCurrentNPC.GetAlpha(color47), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, spriteEffects, 0f);
            }
            break;
        }
        }
    }
 
    private static void DrawNPCDirect_Deerclops(SpriteBatch mySpriteBatch, NPC rCurrentNPC, ref Vector2 screenPos, int typeCache, ref Microsoft.Xna.Framework.Color npcColor, ref Vector2 halfSize, SpriteEffects npcSpriteEffect)
    {
        Texture2D value = TextureAssets.Npc[typeCache].Value;
        Vector2 vector = rCurrentNPC.Bottom - screenPos;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(5, 5, rCurrentNPC.frame.Y / 5, rCurrentNPC.frame.Y % 5, 2, 2);
        Vector2 origin = rectangle.Size() * new Vector2(0.5f, 1f);
        origin.Y -= 4f;
        int num = 106;
        if (rCurrentNPC.spriteDirection == 1)
        {
            origin.X = num;
        }
        else
        {
            origin.X = rectangle.Width - num;
        }
        Microsoft.Xna.Framework.Color value2 = Microsoft.Xna.Framework.Color.White;
        float amount = 0f;
        float amount2 = 0f;
        int num2 = 0;
        float num3 = 0f;
        float num4 = 0f;
        float num5 = 10f;
        Microsoft.Xna.Framework.Color color = npcColor;
        if (rCurrentNPC.localAI[3] > 0f)
        {
            float num6 = rCurrentNPC.localAI[3] / 36f;
            num2 = 2;
            num3 = num6 * num6;
            num4 = 20f;
            value2 = new Microsoft.Xna.Framework.Color(80, 0, 0, 255) * 0.5f;
            amount2 = 1f;
            color = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color, 1f - num6 * num6);
        }
        for (int i = 0; i < num2; i++)
        {
            Microsoft.Xna.Framework.Color value3 = npcColor;
            value3 = Microsoft.Xna.Framework.Color.Lerp(value3, value2, amount);
            value3 = rCurrentNPC.GetAlpha(value3);
            value3 = Microsoft.Xna.Framework.Color.Lerp(value3, value2, amount2);
            value3 *= 1f - num3 * 0.5f;
            Vector2 vector2 = vector;
            mySpriteBatch.Draw(value, vector2 + new Vector2(0f, 1f).RotatedBy((float)i * ((float)Math.PI * 2f) / (float)num2 + GlobalTimeWrappedHourly * num5) * num3 * num4, rectangle, value3, rCurrentNPC.rotation, origin, rCurrentNPC.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
        }
        Microsoft.Xna.Framework.Color color2 = rCurrentNPC.GetAlpha(color);
        Microsoft.Xna.Framework.Color value4 = new Microsoft.Xna.Framework.Color(50, 0, 160);
        float num7 = 0f;
        if (rCurrentNPC.localAI[3] > 0f)
        {
            float amount3 = Utils.Remap(rCurrentNPC.localAI[3], 0f, 20f, 0f, 1f);
            color2 = Microsoft.Xna.Framework.Color.Lerp(color2, value4, amount3);
        }
        if (rCurrentNPC.ai[0] == 7f || rCurrentNPC.ai[0] == 8f)
        {
            num7 = Utils.Remap(rCurrentNPC.ai[1], 20f, 60f, 0f, 2f);
            if (num7 > 1f)
            {
                num7 = 2f - num7;
            }
            color2 = Microsoft.Xna.Framework.Color.Lerp(color2, value4, num7);
            color2 *= 1f - num7;
            float num8 = 5f;
            for (int j = 0; (float)j < num8; j++)
            {
                Vector2 vector3 = vector;
                float num9 = num7 * num7;
                float num10 = 80f * num9;
                float num11 = 80f * num9 + (float)(30 * j) * num9;
                Vector2 vector4 = Vector2.UnitX.RotatedBy((float)j * ((float)Math.PI * 2f) / num8 + GlobalTimeWrappedHourly * 6f) * num10;
                Vector2 vector5 = Vector2.UnitX.RotatedBy((float)j * ((float)Math.PI * 2f) / num8 + GlobalTimeWrappedHourly * 3f * ((float)j * 0.5f)) * num11;
                mySpriteBatch.Draw(value, vector3 + vector4 + vector5, rectangle, color2 * 0.5f, rCurrentNPC.rotation, origin, rCurrentNPC.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
            }
        }
        mySpriteBatch.Draw(value, vector, rectangle, color2, rCurrentNPC.rotation, origin, rCurrentNPC.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
        if (rCurrentNPC.localAI[3] > 0f)
        {
            Texture2D value5 = TextureAssets.Extra[245].Value;
            float num12 = Utils.Remap(rCurrentNPC.localAI[3], 0f, 20f, 0f, 1f);
            Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color(255, 30, 30, 66) * rCurrentNPC.Opacity * num12 * 0.25f * (1f - num7);
            for (int k = 0; k < num2; k++)
            {
                Vector2 vector6 = vector;
                mySpriteBatch.Draw(value5, vector6 + new Vector2(0f, 1f).RotatedBy((float)k * ((float)Math.PI * 2f) / (float)num2 + GlobalTimeWrappedHourly * num5) * num3 * 4f, rectangle, color3, rCurrentNPC.rotation, origin, rCurrentNPC.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
            }
        }
    }
 
    private static void DrawNPCDirect_DeerclopsLeg(SpriteBatch mySpriteBatch, NPC rCurrentNPC, ref Vector2 screenPos, int typeCache, ref Microsoft.Xna.Framework.Color npcColor, ref Vector2 halfSize, SpriteEffects npcSpriteEffect)
    {
        Microsoft.Xna.Framework.Rectangle? sourceRectangle = null;
        int num = 0;
        int num2 = 0;
        mySpriteBatch.Draw(TextureAssets.Npc[typeCache].Value, new Vector2(rCurrentNPC.position.X - screenPos.X + (float)(rCurrentNPC.width / 2) - (float)TextureAssets.Npc[typeCache].Width() * rCurrentNPC.scale / 2f + halfSize.X * rCurrentNPC.scale, rCurrentNPC.position.Y - screenPos.Y + (float)rCurrentNPC.height - (float)TextureAssets.Npc[typeCache].Height() * rCurrentNPC.scale / (float)npcFrameCount[typeCache] + 4f + halfSize.Y * rCurrentNPC.scale + (float)num2 + (float)num + rCurrentNPC.gfxOffY), sourceRectangle, rCurrentNPC.GetAlpha(npcColor), rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
    }
 
    private static void DrawNPCDirect_Faeling(SpriteBatch mySpriteBatch, NPC rCurrentNPC, ref Vector2 screenPos, int typeCache, ref Microsoft.Xna.Framework.Color npcColor, ref Vector2 halfSize, SpriteEffects npcSpriteEffect)
    {
        Texture2D value = TextureAssets.Npc[typeCache].Value;
        Vector2 vector = rCurrentNPC.Center - screenPos;
        int num = 5;
        int horizontalFrames = 4;
        float num2 = ((float)rCurrentNPC.whoAmI * 0.11f + (float)timeForVisualEffects / 360f) % 1f;
        Microsoft.Xna.Framework.Color color = hslToRgb(num2, 1f, 0.65f);
        color.A /= 2;
        float rotation = rCurrentNPC.rotation;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(horizontalFrames, num, 0, rCurrentNPC.frame.Y);
        Vector2 origin = rectangle.Size() / 2f;
        float scale = rCurrentNPC.scale;
        Microsoft.Xna.Framework.Rectangle value2 = value.Frame(horizontalFrames, num, 2);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 1f;
        int num3 = rCurrentNPC.oldPos.Length;
        int num4 = num3 - 1 - 5;
        int num5 = 5;
        int num6 = 3;
        float num7 = 32f;
        float num8 = 16f;
        float fromMax = new Vector2(num7, num8).Length();
        float num9 = Utils.Remap(Vector2.Distance(rCurrentNPC.oldPos[num4], rCurrentNPC.position), 0f, fromMax, 0f, 100f);
        num9 = (int)num9 / 5;
        num9 *= 5f;
        num9 /= 100f;
        num8 *= num9;
        num7 *= num9;
        float num10 = 9f;
        float num11 = 0.5f;
        float num12 = (float)Math.PI;
        for (int num13 = num4; num13 >= num5; num13 -= num6)
        {
            Vector2 vector2 = rCurrentNPC.oldPos[num13] - rCurrentNPC.position;
            float num14 = Utils.Remap(num13, 0f, num3, 1f, 0f);
            float num15 = 1f - num14;
            Vector2 spinningpoint = new Vector2((float)Math.Sin((double)((float)rCurrentNPC.whoAmI / 17f) + timeForVisualEffects / (double)num10 + (double)(num14 * 2f * ((float)Math.PI * 2f))) * num8, 0f - num7) * num15;
            vector2 += spinningpoint.RotatedBy(num12);
            Microsoft.Xna.Framework.Color color3 = hslToRgb((num2 + num15 * num11) % 1f, 1f, 0.5f);
            color3.A = 0;
            mySpriteBatch.Draw(value, vector + vector2, value2, color3 * num14 * 0.16f, rotation, origin, scale * Utils.Remap(num14 * num14, 0f, 1f, 0f, 2.5f), npcSpriteEffect, 0f);
        }
        mySpriteBatch.Draw(value, vector, value2, color2, rotation, origin, scale, npcSpriteEffect, 0f);
        Microsoft.Xna.Framework.Rectangle value3 = value.Frame(horizontalFrames, num, 1, rCurrentNPC.frame.Y);
        Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
        white.A /= 2;
        mySpriteBatch.Draw(value, vector, value3, white, rotation, origin, scale, npcSpriteEffect, 0f);
        mySpriteBatch.Draw(value, vector, rectangle, color, rotation, origin, scale, npcSpriteEffect, 0f);
        float num16 = MathHelper.Clamp((float)Math.Sin(timeForVisualEffects / 60.0) * 0.3f + 0.3f, 0f, 1f);
        float num17 = 0.8f + (float)Math.Sin(timeForVisualEffects / 15.0 * 6.2831854820251465) * 0.3f;
        Microsoft.Xna.Framework.Rectangle value4 = value.Frame(horizontalFrames, num, 3, rCurrentNPC.whoAmI % num);
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.Lerp(color, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), 0.5f) * num16;
        mySpriteBatch.Draw(value, vector, value4, color4, rotation, origin, scale * num17, SpriteEffects.None, 0f);
        Microsoft.Xna.Framework.Rectangle value5 = value.Frame(horizontalFrames, num, 3, 1);
        Microsoft.Xna.Framework.Color color5 = Microsoft.Xna.Framework.Color.Lerp(color, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), 0.5f) * num16;
        mySpriteBatch.Draw(value, vector, value5, color5, rotation, origin, scale * num17, SpriteEffects.None, 0f);
    }
 
    private static void DrawNPCDirect_HallowBoss(SpriteBatch mySpriteBatch, NPC rCurrentNPC, ref Vector2 screenPos, int typeCache, ref Microsoft.Xna.Framework.Color npcColor, ref Vector2 halfSize, SpriteEffects npcSpriteEffect)
    {
        Texture2D value = TextureAssets.Npc[typeCache].Value;
        Vector2 vector = rCurrentNPC.Center - screenPos;
        bool flag = rCurrentNPC.AI_120_HallowBoss_IsInPhase2();
        int num = (int)rCurrentNPC.ai[0];
        Texture2D value2 = TextureAssets.Extra[159].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value2.Frame(1, 11, 0, (int)(rCurrentNPC.localAI[0] / 4f) % 11);
        Microsoft.Xna.Framework.Color color = rCurrentNPC.GetAlpha(npcColor);
        Texture2D value3 = TextureAssets.Extra[158].Value;
        Texture2D value4 = TextureAssets.Extra[160].Value;
        Texture2D value5 = TextureAssets.Extra[157].Value;
        DrawNPCDirect_GetHallowBossArmFrame(rCurrentNPC, out var armFrame_Count, out var armFrameToUseLeft, out var armFrameToUseRight);
        Microsoft.Xna.Framework.Rectangle rectangle2 = value3.Frame(1, armFrame_Count, 0, armFrameToUseLeft);
        Microsoft.Xna.Framework.Rectangle rectangle3 = value4.Frame(1, armFrame_Count, 0, armFrameToUseRight);
        Vector2 origin = rectangle2.Size() / 2f;
        Vector2 origin2 = rectangle3.Size() / 2f;
        int num2 = 0;
        int num3 = 0;
        if (armFrameToUseLeft == 5)
        {
            num2 = 1;
        }
        if (armFrameToUseRight == 5)
        {
            num3 = 1;
        }
        float num4 = 1f;
        int num5 = 0;
        int num6 = 0;
        float num7 = 0f;
        float num8 = 0f;
        float num9 = 0f;
        if (num == 8 || num == 9)
        {
            num7 = Utils.GetLerpValue(0f, 30f, rCurrentNPC.ai[1], clamped: true) * Utils.GetLerpValue(90f, 30f, rCurrentNPC.ai[1], clamped: true);
            num8 = Utils.GetLerpValue(0f, 30f, rCurrentNPC.ai[1], clamped: true) * Utils.GetLerpValue(90f, 70f, rCurrentNPC.ai[1], clamped: true);
            num9 = Utils.GetLerpValue(0f, 15f, rCurrentNPC.ai[1], clamped: true) * Utils.GetLerpValue(45f, 30f, rCurrentNPC.ai[1], clamped: true);
            color = Microsoft.Xna.Framework.Color.Lerp(color, Microsoft.Xna.Framework.Color.White, num7);
            num4 *= 1f - num9;
            num5 = 4;
            num6 = 3;
        }
        if (num == 10)
        {
            num7 = Utils.GetLerpValue(30f, 90f, rCurrentNPC.ai[1], clamped: true) * Utils.GetLerpValue(165f, 90f, rCurrentNPC.ai[1], clamped: true);
            num8 = Utils.GetLerpValue(0f, 60f, rCurrentNPC.ai[1], clamped: true) * Utils.GetLerpValue(180f, 120f, rCurrentNPC.ai[1], clamped: true);
            num9 = Utils.GetLerpValue(0f, 60f, rCurrentNPC.ai[1], clamped: true) * Utils.GetLerpValue(180f, 120f, rCurrentNPC.ai[1], clamped: true);
            color = Microsoft.Xna.Framework.Color.Lerp(color, Microsoft.Xna.Framework.Color.White, num7);
            num4 *= 1f - num9;
            num6 = 4;
        }
        if (num6 + num5 > 0)
        {
            for (int i = -num6; i <= num6 + num5; i++)
            {
                if (i == 0)
                {
                    continue;
                }
                Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.White;
                Vector2 position = vector;
                if (num == 8 || num == 9)
                {
                    float hue = ((float)i + 5f) / 10f;
                    float num10 = 200f;
                    float num11 = (float)timeForVisualEffects / 60f;
                    Vector3 vector2 = Vector3.Transform(matrix: Matrix.CreateRotationX((num11 - 0.3f + (float)i * 0.1f) * 0.7f * ((float)Math.PI * 2f)) * Matrix.CreateRotationY((num11 - 0.8f + (float)i * 0.3f) * 0.7f * ((float)Math.PI * 2f)) * Matrix.CreateRotationZ((num11 + (float)i * 0.5f) * 0.1f * ((float)Math.PI * 2f)), position: Vector3.Forward);
                    num10 += Utils.GetLerpValue(-1f, 1f, vector2.Z, clamped: true) * 150f;
                    Vector2 spinningpoint = new Vector2(vector2.X, vector2.Y) * num10 * num7;
                    float lerpValue = Utils.GetLerpValue(90f, 0f, rCurrentNPC.ai[1], clamped: true);
                    color2 = hslToRgb(hue, 1f, MathHelper.Lerp(0.5f, 1f, lerpValue)) * 0.8f * num8;
                    color2.A /= 3;
                    position += spinningpoint.RotatedBy(rCurrentNPC.ai[1] / 180f * ((float)Math.PI * 2f));
                }
                if (num == 10)
                {
                    if (rCurrentNPC.ai[1] >= 90f)
                    {
                        float num12 = (float)timeForVisualEffects / 90f;
                        int num13 = i;
                        if (num13 < 0)
                        {
                            num13++;
                        }
                        Vector2 vector3 = (((float)num13 + 0.5f) * ((float)Math.PI / 4f) + (float)Math.PI * 2f * num12).ToRotationVector2();
                        position += vector3 * new Vector2(600f * num7, 150f * num7);
                    }
                    else
                    {
                        position += 200f * new Vector2(i, 0f) * num7;
                    }
                    color2 = Microsoft.Xna.Framework.Color.White * 0.8f * num8 * num4;
                    color2.A /= 3;
                }
                if (i > num6)
                {
                    float lerpValue2 = Utils.GetLerpValue(30f, 70f, rCurrentNPC.ai[1], clamped: true);
                    if (lerpValue2 == 0f)
                    {
                        continue;
                    }
                    position = vector + rCurrentNPC.velocity * -3f * ((float)i - 4f) * lerpValue2;
                    color2 *= 1f - num9;
                }
                mySpriteBatch.Draw(value2, position, rectangle, color2, rCurrentNPC.rotation, rectangle.Size() / 2f, rCurrentNPC.scale * 2f, npcSpriteEffect, 0f);
                mySpriteBatch.Draw(value5, position, rectangle, color2, rCurrentNPC.rotation, rectangle.Size() / 2f, rCurrentNPC.scale * 2f, npcSpriteEffect, 0f);
                if (flag)
                {
                    Texture2D value6 = TextureAssets.Extra[187].Value;
                    Microsoft.Xna.Framework.Rectangle value7 = value6.Frame(1, 8, 0, (int)(rCurrentNPC.localAI[0] / 4f) % 8);
                    mySpriteBatch.Draw(value6, position, value7, color2, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
                }
                mySpriteBatch.Draw(value, position, rCurrentNPC.frame, color2, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
                for (int j = 0; j < 2; j++)
                {
                    if (j == num2)
                    {
                        mySpriteBatch.Draw(value3, position, rectangle2, color2, rCurrentNPC.rotation, origin, rCurrentNPC.scale, npcSpriteEffect, 0f);
                    }
                    if (j == num3)
                    {
                        mySpriteBatch.Draw(value4, position, rectangle3, color2, rCurrentNPC.rotation, origin2, rCurrentNPC.scale, npcSpriteEffect, 0f);
                    }
                }
            }
        }
        color *= num4;
        mySpriteBatch.Draw(value2, vector, rectangle, color, rCurrentNPC.rotation, rectangle.Size() / 2f, rCurrentNPC.scale * 2f, npcSpriteEffect, 0f);
        if (!rCurrentNPC.IsABestiaryIconDummy)
        {
            mySpriteBatch.End();
            mySpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.Default, RasterizerState.CullNone, null, Transform);
        }
        DrawData value8 = new DrawData(value5, vector, rectangle, color, rCurrentNPC.rotation, rectangle.Size() / 2f, rCurrentNPC.scale * 2f, npcSpriteEffect);
        GameShaders.Misc["HallowBoss"].Apply(value8);
        value8.Draw(mySpriteBatch);
        pixelShader.CurrentTechnique.Passes[0].Apply();
        if (!rCurrentNPC.IsABestiaryIconDummy)
        {
            mySpriteBatch.End();
            mySpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        }
        float num14 = (float)Math.Sin(GlobalTimeWrappedHourly * ((float)Math.PI * 2f) * 0.5f) * 0.5f + 0.5f;
        Microsoft.Xna.Framework.Color color3 = hslToRgb((num14 * 0.08f + 0.6f) % 1f, 1f, 0.5f);
        color3.A = 0;
        color3 *= 0.6f;
        if (NPC.ShouldEmpressBeEnraged())
        {
            color3 = OurFavoriteColor;
            color3.A = 0;
            color3 *= 0.3f;
        }
        color3 *= num4 * rCurrentNPC.Opacity;
        if (flag)
        {
            Texture2D value9 = TextureAssets.Extra[187].Value;
            Microsoft.Xna.Framework.Rectangle value10 = value9.Frame(1, 8, 0, (int)(rCurrentNPC.localAI[0] / 4f) % 8);
            mySpriteBatch.Draw(value9, vector, value10, color, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
            for (float num15 = 0f; num15 < 1f; num15 += 0.25f)
            {
                Vector2 vector4 = rCurrentNPC.rotation.ToRotationVector2().RotatedBy(num15 * ((float)Math.PI * 2f) + (float)Math.PI / 4f) * MathHelper.Lerp(2f, 8f, num14);
                mySpriteBatch.Draw(value9, vector + vector4, value10, color3, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
            }
        }
        mySpriteBatch.Draw(value, vector, rCurrentNPC.frame, color, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
        if (flag)
        {
            Texture2D value11 = TextureAssets.Extra[188].Value;
            for (float num16 = 0f; num16 < 1f; num16 += 0.25f)
            {
                Vector2 vector5 = rCurrentNPC.rotation.ToRotationVector2().RotatedBy(num16 * ((float)Math.PI * 2f) + (float)Math.PI / 4f) * MathHelper.Lerp(2f, 8f, num14);
                mySpriteBatch.Draw(value11, vector + vector5, null, color3, rCurrentNPC.rotation, halfSize, rCurrentNPC.scale, npcSpriteEffect, 0f);
            }
        }
        for (int k = 0; k < 2; k++)
        {
            if (k == num2)
            {
                mySpriteBatch.Draw(value3, vector, rectangle2, color, rCurrentNPC.rotation, origin, rCurrentNPC.scale, npcSpriteEffect, 0f);
            }
            if (k == num3)
            {
                mySpriteBatch.Draw(value4, vector, rectangle3, color, rCurrentNPC.rotation, origin2, rCurrentNPC.scale, npcSpriteEffect, 0f);
            }
        }
    }
 
    private static void DrawNPCDirect_GetHallowBossArmFrame(NPC rCurrentNPC, out int armFrame_Count, out int armFrameToUseLeft, out int armFrameToUseRight)
    {
        int num = 0;
        int num2 = 1;
        int num3 = 2;
        int num4 = 3;
        int num5 = 4;
        int num6 = 5;
        int num7 = 6;
        armFrame_Count = 7;
        armFrameToUseLeft = num;
        armFrameToUseRight = num;
        float num8 = rCurrentNPC.ai[1];
        int num9 = num;
        switch ((int)rCurrentNPC.ai[0])
        {
        case 6:
            armFrameToUseRight = (armFrameToUseLeft = ((num8 < 6f) ? num3 : ((num8 < 174f) ? num4 : ((!(num8 < 180f)) ? num : num3))));
            break;
        case 0:
            armFrameToUseRight = (armFrameToUseLeft = ((num8 < 106f) ? num2 : ((!(num8 < 110f)) ? num : num3)));
            break;
        case 2:
        case 11:
            num9 = ((num8 < 5f) ? num3 : ((!(num8 < 65f)) ? num3 : num4));
            armFrameToUseLeft = num9;
            break;
        case 5:
            num9 = ((num8 < 6f) ? num3 : ((!(num8 < 54f)) ? num3 : num4));
            armFrameToUseRight = num9;
            break;
        case 4:
        case 10:
            armFrameToUseRight = (armFrameToUseLeft = ((num8 < 6f) ? num3 : ((!(num8 < 54f)) ? num3 : num4)));
            break;
        case 8:
        case 9:
        {
            num9 = ((num8 < 10f) ? num3 : ((num8 < 20f) ? num4 : ((!(num8 < 30f)) ? num6 : num3)));
            int num13 = num9;
            int num14 = num9;
            int num15 = (int)rCurrentNPC.ai[3];
            int num16 = -1;
            if (num8 < 30f)
            {
                if (num15 == -1 * num16)
                {
                    num14 = num2;
                }
                if (num15 == num16)
                {
                    num13 = num2;
                }
            }
            int num17 = num6;
            int num18 = num7;
            if (num15 == num16 && num14 == num17)
            {
                num14 = num18;
            }
            if (num15 == -1 * num16 && num13 == num17)
            {
                num13 = num18;
            }
            armFrameToUseLeft = num14;
            armFrameToUseRight = num13;
            break;
        }
        case 7:
        {
            bool isExpertMode = GameModeInfo.IsExpertMode;
            int num10 = (isExpertMode ? 40 : 60);
            int num11 = 0;
            int num12 = 5;
            if (num8 < (float)(num11 + num12))
            {
                armFrameToUseLeft = num3;
                break;
            }
            num11 += num12;
            if (num8 < (float)(num11 + num10 - num12))
            {
                armFrameToUseLeft = num4;
                break;
            }
            num11 += num10 - num12;
            if (num8 < (float)(num11 + num12))
            {
                armFrameToUseLeft = num4;
                armFrameToUseRight = num3;
                break;
            }
            num11 += num12;
            if (num8 < (float)(num11 + num10 - num12))
            {
                armFrameToUseLeft = num4;
                armFrameToUseRight = num4;
                break;
            }
            num11 += num10 - num12;
            if (num8 < (float)(num11 + num10))
            {
                armFrameToUseLeft = num5;
                armFrameToUseRight = num4;
                break;
            }
            num11 += num10;
            if (num8 < (float)(num11 + num10))
            {
                armFrameToUseLeft = num5;
                armFrameToUseRight = num5;
                break;
            }
            num11 += num10;
            if (isExpertMode)
            {
                if (num8 < (float)(num11 + num12))
                {
                    armFrameToUseLeft = num4;
                    armFrameToUseRight = num5;
                    break;
                }
                num11 += num12;
                if (num8 < (float)(num11 + num10 - num12))
                {
                    armFrameToUseLeft = num2;
                    armFrameToUseRight = num5;
                    break;
                }
                num11 += num10 - num12;
                if (num8 < (float)(num11 + num12))
                {
                    armFrameToUseLeft = num2;
                    armFrameToUseRight = num4;
                    break;
                }
                num11 += num12;
                if (num8 < (float)(num11 + num10 - num12))
                {
                    armFrameToUseLeft = num2;
                    armFrameToUseRight = num2;
                    break;
                }
                num11 += num10 - num12;
            }
            if (num8 >= (float)num11)
            {
                armFrameToUseLeft = num3;
                armFrameToUseRight = num3;
            }
            break;
        }
        case 1:
        case 3:
            break;
        }
    }
 
    private static void DrawNPC_SlimeItem(NPC rCurrentNPC, int typeCache, Microsoft.Xna.Framework.Color npcColor, float addedRotation)
    {
        int num = (int)rCurrentNPC.ai[1];
        float num2 = 1f;
        float num3 = 22f * rCurrentNPC.scale;
        float num4 = 18f * rCurrentNPC.scale;
        GetItemDrawFrame(num, out var itemTexture, out var rectangle);
        float num5 = rectangle.Width;
        float num6 = rectangle.Height;
        bool num7 = (int)rCurrentNPC.ai[0] == -999;
        if (num7)
        {
            num3 = 14f * rCurrentNPC.scale;
            num4 = 14f * rCurrentNPC.scale;
        }
        if (num5 > num3)
        {
            num2 *= num3 / num5;
            num5 *= num2;
            num6 *= num2;
        }
        if (num6 > num4)
        {
            num2 *= num4 / num6;
            num5 *= num2;
            num6 *= num2;
        }
        float num8 = -1f;
        float num9 = 1f;
        int num10 = rCurrentNPC.frame.Y / (TextureAssets.Npc[typeCache].Height() / npcFrameCount[typeCache]);
        num9 -= (float)num10;
        num8 += (float)(num10 * 2);
        float num11 = 0.2f;
        num11 -= 0.3f * (float)num10;
        if (num7)
        {
            num11 = 0f;
            num9 -= 6f;
            num8 -= num5 * addedRotation;
        }
        if (num == 75)
        {
            npcColor = new Microsoft.Xna.Framework.Color(255, 255, 255, 0);
            num11 *= 0.3f;
            num9 -= 2f;
        }
        npcColor = rCurrentNPC.GetShimmerColor(npcColor);
        spriteBatch.Draw(itemTexture, new Vector2(rCurrentNPC.Center.X - screenPosition.X + num8, rCurrentNPC.Center.Y - screenPosition.Y + rCurrentNPC.gfxOffY + num9), rectangle, npcColor, num11, rectangle.Size() / 2f, num2, SpriteEffects.None, 0f);
    }
 
    public static void GetItemDrawFrame(int item, out Texture2D itemTexture, out Microsoft.Xna.Framework.Rectangle itemFrame)
    {
        instance.LoadItem(item);
        itemTexture = TextureAssets.Item[item].Value;
        if (itemAnimations[item] != null)
        {
            itemFrame = itemAnimations[item].GetFrame(itemTexture);
        }
        else
        {
            itemFrame = itemTexture.Frame();
        }
    }
 
    protected void DrawNPCExtras(NPC n, bool beforeDraw, float addHeight, float addY, Microsoft.Xna.Framework.Color npcColor, Vector2 halfSize, SpriteEffects npcSpriteEffect, Vector2 screenPosition)
    {
        if (!beforeDraw && n.UsesPartyHat())
        {
            int num = n.frame.Y / n.frame.Height;
            int[] array = NPCID.Sets.TownNPCsFramingGroups[NPCID.Sets.NPCFramingGroup[n.type]];
            if (num >= array.Length)
            {
                num = 0;
            }
            Texture2D value = TextureAssets.Extra[72].Value;
            int num2 = 0;
            switch (n.GetPartyHatColor())
            {
            case PartyHatColor.Pink:
                num2 = 16;
                break;
            case PartyHatColor.Cyan:
                num2 = 17;
                break;
            case PartyHatColor.Purple:
                num2 = 18;
                break;
            case PartyHatColor.White:
                num2 = 19;
                break;
            }
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(20, 1, num2 % 20);
            rectangle.Width -= 2;
            rectangle.Height -= 2;
            int num3 = 0;
            int num4 = 0;
            int num5 = n.spriteDirection;
            if (n.type == 663)
            {
                num3 = 1;
            }
            if (n.type == 637)
            {
                num3 = 6;
                switch (num)
                {
                case 19:
                case 22:
                case 23:
                case 24:
                case 25:
                case 26:
                case 27:
                    num3 -= 2;
                    break;
                case 11:
                case 12:
                case 13:
                case 14:
                case 15:
                    num3 += 2;
                    break;
                }
            }
            if (n.type == 638)
            {
                num3 = 12;
            }
            if (n.type == 656)
            {
                num3 = 6;
                switch (num)
                {
                case 1:
                case 2:
                case 3:
                    num3 -= 2;
                    break;
                case 18:
                case 19:
                case 20:
                case 21:
                case 22:
                case 23:
                case 24:
                case 25:
                    num3 -= 4;
                    break;
                case 8:
                    num3 -= 2;
                    break;
                }
            }
            if (NPCID.Sets.IsTownSlime[n.type])
            {
                num5 *= -1;
                switch (n.type)
                {
                default:
                    num3 = 1;
                    break;
                case 670:
                    num3 = -1;
                    break;
                case 681:
                    num3 = -2;
                    break;
                case 682:
                    num3 = -1;
                    num4 = 2;
                    break;
                case 683:
                    num3 = -1;
                    num4 = -2;
                    break;
                case 684:
                    num3 = -4;
                    break;
                case 679:
                    break;
                }
            }
            if (n.IsShimmerVariant)
            {
                switch (n.type)
                {
                case 38:
                    num3 += 2;
                    num4 = -2;
                    break;
                case 178:
                case 228:
                    num3 = -4;
                    num4 = -4;
                    break;
                case 107:
                    num3 = 2;
                    num4 = -6;
                    break;
                case 54:
                    num4 = -6;
                    break;
                case 160:
                    num4 = -2;
                    break;
                case 108:
                case 124:
                case 208:
                case 209:
                case 227:
                    num4 = -4;
                    break;
                }
            }
            Vector2 vector = n.Top + new Vector2(-2 * num5, n.gfxOffY);
            vector.X += num3 * num5;
            vector.Y += array[num];
            vector.Y += num4;
            vector.Y += NPCID.Sets.HatOffsetY[n.type];
            int num6 = 0;
            if (n.ai[0] == 5f)
            {
                num6 = -4;
                if (n.type == 38)
                {
                    num6 = -8;
                }
                if (n.type == 124)
                {
                    num6 = -2;
                }
                if (n.type == 550)
                {
                    num6 = -4;
                }
                if (n.type == 588)
                {
                    num6 = -4;
                }
                if (n.type == 108 || n.type == 178)
                {
                    num6 = -6;
                }
                if (n.type == 637)
                {
                    num6 = -12;
                }
                if (n.type == 663)
                {
                    num6 = -8;
                }
            }
            vector.Y += num6;
            if (n.type == 229 && n.ai[0] == 12f)
            {
                vector.X -= num5 * 4;
            }
            if (n.type == 550 && n.ai[0] == 5f)
            {
                vector.X += num5 * 7;
            }
            Vector2 origin = rectangle.Size() - new Vector2(rectangle.Width / 2, 12f);
            int num7 = 0;
            switch (n.type)
            {
            case 550:
                num7 = -4;
                break;
            case 588:
                num7 = 0;
                break;
            case 227:
                num7 = -4;
                break;
            case 228:
                num7 = -2;
                break;
            case 17:
            case 18:
            case 19:
            case 20:
            case 22:
            case 124:
            case 229:
            case 353:
            case 633:
            case 637:
            case 638:
            case 656:
            case 670:
            case 678:
            case 679:
            case 680:
            case 681:
            case 682:
            case 683:
            case 684:
                num7 = -1;
                break;
            case 37:
            case 38:
            case 54:
            case 107:
            case 108:
            case 160:
            case 207:
            case 209:
                num7 = -3;
                break;
            case 178:
            case 208:
            case 369:
                num7 = 1;
                break;
            }
            vector.X += num7 * num5;
            vector.X += 4 * num5;
            SpriteEffects spriteEffects = npcSpriteEffect;
            if (NPCID.Sets.IsTownSlime[n.type])
            {
                spriteEffects ^= SpriteEffects.FlipHorizontally;
            }
            float num8 = 1f;
            if (n.shimmerTransparency > 0f)
            {
                num8 *= 1f - n.shimmerTransparency;
            }
            spriteBatch.Draw(value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), rectangle, npcColor * n.Opacity * num8, 0f, origin, n.scale, spriteEffects, 0f);
        }
        if (!beforeDraw && n.type == 681)
        {
            spriteBatch.Draw(TextureAssets.Extra[250].Value, new Vector2(n.position.X - screenPosition.X + (float)(n.width / 2) - (float)TextureAssets.Npc[n.type].Width() * n.scale / 2f + halfSize.X * n.scale, n.position.Y - screenPosition.Y + (float)n.height - (float)TextureAssets.Npc[n.type].Height() * n.scale / (float)npcFrameCount[n.type] + 4f + halfSize.Y * n.scale + addHeight + addY + n.gfxOffY), n.frame, n.GetAlpha(npcColor), n.rotation, halfSize, n.scale, npcSpriteEffect, 0f);
        }
        if (NPCID.Sets.AttackType[n.type] == 1 && n.ai[0] == 12f && !beforeDraw)
        {
            if (n.type == 228 || n.type == 229 || n.type == 209)
            {
                return;
            }
            float num9 = n.ai[2];
            Vector2 vector2 = OffsetsNPCOffhand[2];
            if (n.spriteDirection == 1)
            {
                vector2.X *= -1f;
            }
            Vector2 vector3 = n.Bottom - vector2;
            if (n.type == 22 && n.ai[2] > -0.1f)
            {
                vector3.Y += 4f;
            }
            if (n.type == 368 && hardMode && n.ai[2] > -0.1f)
            {
                vector3.Y += 4f;
            }
            if (n.type == 368 && !hardMode && n.ai[2] < -0.1f)
            {
                vector3.Y -= 8f;
            }
            float rotation = num9 * ((float)Math.PI / 2f) * (float)n.spriteDirection;
            float num10 = 1f;
            int itemtype = 0;
            int num11 = 4;
            if (n.type == 19)
            {
                itemtype = (hardMode ? 98 : 95);
                if (hardMode)
                {
                    vector3.X -= 10 * n.direction;
                    vector3.Y += 4f;
                }
            }
            else if (n.type == 22)
            {
                itemtype = 39;
                num11 = 18;
            }
            else if (n.type == 178)
            {
                itemtype = 434;
            }
            else if (n.type == 227)
            {
                itemtype = 3350;
                num11 = 16;
                num10 = 0.85f;
            }
            else if (n.type == 368)
            {
                itemtype = (hardMode ? 2223 : 2269);
                if (hardMode)
                {
                    num11 = 18;
                }
                else
                {
                    if (n.ai[2] < -0.1f)
                    {
                        num11 = 28;
                    }
                    num10 = 0.75f;
                }
            }
            Vector2 vector4 = DrawPlayerItemPos(1f, itemtype);
            GetItemDrawFrame(itemtype, out var itemTexture, out var value2);
            int num12 = (int)vector4.X - num11;
            Vector2 origin2 = new Vector2(-num12, value2.Height / 2);
            if (n.spriteDirection == -1)
            {
                origin2 = new Vector2(value2.Width + num12, value2.Height / 2);
            }
            spriteBatch.Draw(itemTexture, new Vector2((int)(vector3.X - screenPosition.X), (int)(vector3.Y - screenPosition.Y)), value2, npcColor, rotation, origin2, n.scale * num10, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
            if (n.type == 22 && n.frame.Y / (TextureAssets.Npc[n.type].Height() / npcFrameCount[n.type]) >= 21)
            {
                Texture2D value3 = TextureAssets.Extra[52].Value;
                if (n.IsShimmerVariant)
                {
                    value3 = TextureAssets.Extra[264].Value;
                }
                Microsoft.Xna.Framework.Rectangle value4 = value3.Frame(1, 5, 0, n.frame.Y / (TextureAssets.Npc[n.type].Height() / npcFrameCount[n.type]) - 21);
                spriteBatch.Draw(value3, new Vector2(n.position.X - screenPosition.X + (float)(n.width / 2) - (float)TextureAssets.Npc[n.type].Width() * n.scale / 2f + halfSize.X * n.scale, n.position.Y - screenPosition.Y + (float)n.height - (float)TextureAssets.Npc[n.type].Height() * n.scale / (float)npcFrameCount[n.type] + 4f + halfSize.Y * n.scale + addHeight + addY + n.gfxOffY), value4, n.GetAlpha(npcColor), n.rotation, halfSize, n.scale, npcSpriteEffect, 0f);
            }
            else if (n.type == 368 && n.frame.Y / (TextureAssets.Npc[n.type].Height() / npcFrameCount[n.type]) >= 21)
            {
                Texture2D value5 = TextureAssets.Extra[53].Value;
                if (n.IsShimmerVariant)
                {
                    value5 = TextureAssets.Extra[265].Value;
                }
                Microsoft.Xna.Framework.Rectangle value6 = value5.Frame(1, 5, 0, n.frame.Y / (TextureAssets.Npc[n.type].Height() / npcFrameCount[n.type]) - 21);
                spriteBatch.Draw(value5, new Vector2(n.position.X - screenPosition.X + (float)(n.width / 2) - (float)TextureAssets.Npc[n.type].Width() * n.scale / 2f + halfSize.X * n.scale, n.position.Y - screenPosition.Y + (float)n.height - (float)TextureAssets.Npc[n.type].Height() * n.scale / (float)npcFrameCount[n.type] + 4f + halfSize.Y * n.scale + addHeight + addY + n.gfxOffY), value6, n.GetAlpha(npcColor), n.rotation, halfSize, n.scale, npcSpriteEffect, 0f);
            }
        }
        if (NPCID.Sets.AttackType[n.type] == 2 && (n.ai[0] == 14f || (n.ai[0] == 24f && n.frameCounter < 240.0)) && !beforeDraw)
        {
            Texture2D value7 = TextureAssets.Extra[51].Value;
            Vector2 vector5 = n.Bottom + new Vector2(0f, n.gfxOffY + 4f);
            Microsoft.Xna.Framework.Rectangle rectangle2 = value7.Frame(1, 4, 0, (int)n.frameCounter % 48 / 12);
            Vector2 origin3 = rectangle2.Size() * new Vector2(0.5f, 1f);
            spriteBatch.Draw(value7, new Vector2((int)(vector5.X - screenPosition.X), (int)(vector5.Y - screenPosition.Y)), rectangle2, n.GetMagicAuraColor(), 0f, origin3, n.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
        }
        if (NPCID.Sets.AttackType[n.type] == 3 && n.ai[0] == 15f)
        {
            int num13 = 32;
            float num14 = 0f;
            Vector2 zero = Vector2.Zero;
            short num15 = 4;
            if (n.type == 207)
            {
                num15 = 3349;
                num14 = 0.15f;
                if (beforeDraw)
                {
                    return;
                }
                if (n.ai[1] > (float)NPCID.Sets.AttackTime[n.type] * 0.66f)
                {
                    zero.Y = 12f;
                }
            }
            else if (n.type == 353)
            {
                num15 = 3352;
                num14 = 0.15f;
                if (!beforeDraw)
                {
                    return;
                }
                if (n.ai[1] > (float)NPCID.Sets.AttackTime[n.type] * 0.66f)
                {
                    zero.Y = 12f;
                }
            }
            else if (n.type == 441)
            {
                num15 = 3351;
                num13 = 28;
                num14 = 0.1f;
                if (!beforeDraw)
                {
                    return;
                }
                if (n.ai[1] > (float)NPCID.Sets.AttackTime[n.type] * 0.66f)
                {
                    zero.Y = 12f;
                }
            }
            GetItemDrawFrame(num15, out var itemTexture2, out var rectangle3);
            Tuple<Vector2, float> swingStats = n.GetSwingStats(NPCID.Sets.AttackTime[n.type] * 2, (int)n.ai[1], n.spriteDirection, num13, num13);
            Vector2 vector6 = swingStats.Item1 + (swingStats.Item1 - n.Center) * num14 + zero;
            Vector2 origin4 = rectangle3.Size() * new Vector2((n.spriteDirection != 1) ? 1 : 0, 1f);
            spriteBatch.Draw(itemTexture2, new Vector2((int)(vector6.X - screenPosition.X), (int)(vector6.Y - screenPosition.Y)), rectangle3, n.GetAlpha(npcColor), swingStats.Item2, origin4, n.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
        }
        if (n.type == 550 && n.ai[0] == 18f)
        {
            if (beforeDraw)
            {
                return;
            }
            instance.LoadItem(353);
            Texture2D value8 = TextureAssets.Item[353].Value;
            int num16 = 32;
            float num17 = 0.15f;
            Vector2 zero2 = Vector2.Zero;
            Microsoft.Xna.Framework.Rectangle rectangle4 = value8.Frame(1, 3, 0, 1);
            int num18 = (int)n.ai[2];
            if (num18 >= 0 && num18 < 255)
            {
                Player player = Main.player[num18];
                bool flag = player.HeldItem.type == 353 && player.direction == Math.Sign(n.Center.X - player.Center.X);
                float num19 = player.Hitbox.Distance(n.Center);
                float num20 = n.localAI[3];
                if (num19 < 46f && flag)
                {
                    n.localAI[3] = 1f;
                    if (n.localAI[3] != num20)
                    {
                        Vector2 vector7 = n.Center + new Vector2(n.spriteDirection * 30, -6f);
                        Vector2 vector8 = new Vector2(10f, 10f);
                        for (int i = 0; i < 30; i++)
                        {
                            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);
                            obj.noGravity = true;
                            obj.velocity *= 1f;
                            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;
                        }
                    }
                }
                else if (n.localAI[3] == 1f)
                {
                    n.localAI[3] = 2f;
                }
            }
            Tuple<Vector2, float> swingStats2 = n.GetSwingStats(40, 12, n.spriteDirection, num16, num16);
            Vector2 vector9 = swingStats2.Item1 + (swingStats2.Item1 - n.Center) * num17 + zero2;
            Vector2 origin5 = rectangle4.Size() * new Vector2((n.spriteDirection != 1) ? 1 : 0, 1f);
            spriteBatch.Draw(value8, new Vector2((int)(vector9.X - screenPosition.X), (int)(vector9.Y - screenPosition.Y)), rectangle4, n.GetAlpha(npcColor), swingStats2.Item2, origin5, n.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
        }
        if (beforeDraw || n.ai[0] != 23f)
        {
            return;
        }
        int num21 = (int)n.ai[2];
        if (num21 <= 0 || num21 > ItemID.Count)
        {
            return;
        }
        GetItemDrawFrame(num21, out var itemTexture3, out var rectangle5);
        int num22 = 0;
        num22 = (((int)n.frameCounter < 6) ? 1 : 2);
        if (n.ai[1] < 6f)
        {
            num22 = 1;
        }
        if (num22 == 0)
        {
            return;
        }
        Vector2 vector10 = Vector2.Zero;
        if (num22 == 1)
        {
            vector10 = new Vector2(10f, 6f);
        }
        if (num22 == 2)
        {
            vector10 = new Vector2(16f, 0f);
        }
        if (!npcSpriteEffect.HasFlag(SpriteEffects.FlipHorizontally))
        {
            vector10.X *= -1f;
        }
        if (n.type == 369)
        {
            vector10.X *= 0.5f;
            vector10.Y += 4f;
        }
        if (n.type == 453)
        {
            vector10.Y += 8f;
        }
        if (n.type == 550)
        {
            if (num21 == 353)
            {
                rectangle5 = itemTexture3.Frame(1, 3, 0, 1);
            }
            vector10.Y += 6f;
        }
        Vector2 vector11 = n.Center + vector10;
        Vector2 origin6 = rectangle5.Size() * new Vector2((n.spriteDirection != 1) ? 1 : 0, 1f);
        Vector2 position = new Vector2((int)(vector11.X - screenPosition.X), (int)(vector11.Y - screenPosition.Y));
        Microsoft.Xna.Framework.Color alpha = n.GetAlpha(npcColor);
        spriteBatch.Draw(itemTexture3, position, rectangle5, alpha, 0f, origin6, n.scale, npcSpriteEffect ^ SpriteEffects.FlipHorizontally, 0f);
    }
 
    private void DrawProj_LightsBane(Projectile proj)
    {
        spriteBatch.End();
        if (_multiplyBlendState == null)
        {
            _ = BlendState.AlphaBlend;
            _ = BlendState.Additive;
            _multiplyBlendState = new BlendState
            {
                ColorBlendFunction = BlendFunction.ReverseSubtract,
                ColorDestinationBlend = Blend.One,
                ColorSourceBlend = Blend.SourceAlpha,
                AlphaBlendFunction = BlendFunction.ReverseSubtract,
                AlphaDestinationBlend = Blend.One,
                AlphaSourceBlend = Blend.SourceAlpha
            };
        }
        BlendState multiplyBlendState = _multiplyBlendState;
        spriteBatch.Begin(SpriteSortMode.Deferred, multiplyBlendState, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        Vector2 position = proj.Center - screenPosition;
        LoadProjectile(proj.type);
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 13, 0, proj.frame);
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = new Vector2(0.7f, 0.7f) * proj.scale;
        float num = Utils.Remap(proj.frame, 0f, 3f, 0f, 1f) * Utils.Remap(proj.frame, 4f, 12f, 1f, 0f);
        Microsoft.Xna.Framework.Rectangle value = val.Frame(1, 13, 0, 12);
        Vector2 origin = vector + new Vector2(0f, 0f);
        spriteBatch.Draw(val.Value, position, value, Microsoft.Xna.Framework.Color.White * 0.3f * num, proj.rotation, origin, new Vector2(1f, 6f) * vector2, SpriteEffects.None, 0f);
        spriteBatch.Draw(val.Value, position, value, Microsoft.Xna.Framework.Color.White * 0.3f * num, proj.rotation, origin, new Vector2(2f, 2f) * vector2, SpriteEffects.None, 0f);
        spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.White, proj.rotation, vector, vector2, SpriteEffects.None, 0f);
        spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.White, proj.rotation, vector, vector2, SpriteEffects.None, 0f);
        spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.White, proj.rotation, vector, vector2, SpriteEffects.None, 0f);
        spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.White, proj.rotation, vector, vector2, SpriteEffects.None, 0f);
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.Magenta, proj.rotation, vector, vector2, SpriteEffects.None, 0f);
        spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.Magenta, proj.rotation, vector, vector2, SpriteEffects.None, 0f);
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
    }
 
    private void DrawProj_NightsEdge(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float num = proj.scale * 1.1f;
        SpriteEffects effects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        float num2 = proj.localAI[0] / proj.ai[1];
        float num3 = Utils.Remap(num2, 0f, 0.6f, 0f, 1f) * Utils.Remap(num2, 0.6f, 1f, 1f, 0f);
        float num4 = 0.975f;
        float fromValue = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        fromValue = Utils.Remap(fromValue, 0.2f, 1f, 0f, 1f);
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(40, 20, 60);
        spriteBatch.Draw(val.Value, vector, rectangle, color * fromValue * num3, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * -1f * (1f - num2), origin, num * num4, effects, 0f);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(80, 40, 180);
        Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.White * num3 * 0.5f;
        color3.A = (byte)((float)(int)color3.A * (1f - fromValue));
        Microsoft.Xna.Framework.Color color4 = color3 * fromValue * 0.5f;
        color4.G = (byte)((float)(int)color4.G * fromValue);
        color4.R = (byte)((float)(int)color4.R * (0.25f + fromValue * 0.75f));
        spriteBatch.Draw(val.Value, vector, rectangle, color4 * 0.15f, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, new Microsoft.Xna.Framework.Color(80, 30, 160) * fromValue * num3 * 0.3f, proj.rotation, origin, num * 0.8f, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color2 * fromValue * num3 * 0.7f, proj.rotation, origin, num * num4, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.3f * num3 * (1f - fromValue * 0.7f), proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        Vector2 drawpos = vector + (proj.rotation + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 2f) * proj.ai[0]).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * num;
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * 0.5f, color2, num2, 0f, 0.5f, 0.5f, 1f, (float)Math.PI / 4f, new Vector2(2f, 2f), Vector2.One);
    }
 
    private void DrawProj_Excalibur(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float num = proj.scale * 1.1f;
        SpriteEffects effects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        float num2 = proj.localAI[0] / proj.ai[1];
        float num3 = Utils.Remap(num2, 0f, 0.6f, 0f, 1f) * Utils.Remap(num2, 0.6f, 1f, 1f, 0f);
        float num4 = 0.975f;
        float fromValue = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        fromValue = Utils.Remap(fromValue, 0.2f, 1f, 0f, 1f);
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(180, 160, 60);
        spriteBatch.Draw(val.Value, vector, rectangle, color * fromValue * num3, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * -1f * (1f - num2), origin, num, effects, 0f);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(255, 240, 150);
        Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color(255, 255, 80);
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.White * num3 * 0.5f;
        color4.A = (byte)((float)(int)color4.A * (1f - fromValue));
        Microsoft.Xna.Framework.Color color5 = color4 * fromValue * 0.5f;
        color5.G = (byte)((float)(int)color5.G * fromValue);
        color5.B = (byte)((float)(int)color5.R * (0.25f + fromValue * 0.75f));
        spriteBatch.Draw(val.Value, vector, rectangle, color5 * 0.15f, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color3 * fromValue * num3 * 0.3f, proj.rotation, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color2 * fromValue * num3 * 0.5f, proj.rotation, origin, num * num4, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.6f * num3, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.5f * num3, proj.rotation + proj.ai[0] * -0.05f, origin, num * 0.8f, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.4f * num3, proj.rotation + proj.ai[0] * -0.1f, origin, num * 0.6f, effects, 0f);
        for (float num5 = 0f; num5 < 8f; num5 += 1f)
        {
            float num6 = proj.rotation + proj.ai[0] * num5 * ((float)Math.PI * -2f) * 0.025f + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 4f) * proj.ai[0];
            Vector2 drawpos = vector + num6.ToRotationVector2() * ((float)val.Width() * 0.5f - 6f) * num;
            float num7 = num5 / 9f;
            DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * num7, color3, num2, 0f, 0.5f, 0.5f, 1f, num6, new Vector2(0f, Utils.Remap(num2, 0f, 1f, 3f, 0f)) * num, Vector2.One * num);
        }
        Vector2 drawpos2 = vector + (proj.rotation + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 4f) * proj.ai[0]).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * num;
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos2, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * 0.5f, color3, num2, 0f, 0.5f, 0.5f, 1f, 0f, new Vector2(2f, Utils.Remap(num2, 0f, 1f, 4f, 1f)) * num, Vector2.One * num);
    }
 
    private void DrawProj_TheHorsemansBlade(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float num = proj.scale * 1.1f;
        SpriteEffects effects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        float num2 = proj.localAI[0] / proj.ai[1];
        float num3 = Utils.Remap(num2, 0f, 0.6f, 0f, 1f) * Utils.Remap(num2, 0.6f, 1f, 1f, 0f);
        float num4 = 0.975f;
        float fromValue = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        fromValue = Utils.Remap(fromValue, 0.2f, 1f, 0f, 1f);
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(193, 43, 43);
        spriteBatch.Draw(val.Value, vector, rectangle, color * fromValue * num3, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * -1f * (1f - num2), origin, num, effects, 0f);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(247, 115, 0);
        Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color(255, 202, 130);
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.White * num3 * 0.5f;
        color4.A = (byte)((float)(int)color4.A * (1f - fromValue));
        Microsoft.Xna.Framework.Color color5 = color4 * fromValue * 0.5f;
        color5.G = (byte)((float)(int)color5.G * fromValue);
        color5.B = (byte)((float)(int)color5.R * (0.25f + fromValue * 0.75f));
        spriteBatch.Draw(val.Value, vector, rectangle, color5 * 0.15f, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color3 * fromValue * num3 * 0.3f, proj.rotation, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color2 * fromValue * num3 * 0.5f, proj.rotation, origin, num * num4, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.6f * num3, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.5f * num3, proj.rotation + proj.ai[0] * -0.05f, origin, num * 0.8f, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.4f * num3, proj.rotation + proj.ai[0] * -0.1f, origin, num * 0.6f, effects, 0f);
        for (float num5 = 0f; num5 < 8f; num5 += 1f)
        {
            float num6 = proj.rotation + proj.ai[0] * num5 * ((float)Math.PI * -2f) * 0.025f + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 4f) * proj.ai[0];
            Vector2 drawpos = vector + num6.ToRotationVector2() * ((float)val.Width() * 0.5f - 6f) * num;
            float num7 = num5 / 9f;
            DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * num7, color3, num2, 0f, 0.5f, 0.5f, 1f, num6, new Vector2(0f, Utils.Remap(num2, 0f, 1f, 3f, 0f)) * num, Vector2.One * num);
        }
        Vector2 drawpos2 = vector + (proj.rotation + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 4f) * proj.ai[0]).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * num;
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos2, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * 0.5f, color3, num2, 0f, 0.5f, 0.5f, 1f, (float)Math.PI / 4f, new Vector2(Utils.Remap(num2, 0f, 1f, 4f, 1f)) * num, Vector2.One * num);
    }
 
    private void DrawProj_TrueExcalibur(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float num = proj.scale * 1.1f;
        SpriteEffects effects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        float num2 = proj.localAI[0] / proj.ai[1];
        float num3 = Utils.Remap(num2, 0f, 0.6f, 0f, 1f) * Utils.Remap(num2, 0.6f, 1f, 1f, 0f);
        float num4 = 0.975f;
        float amount = num3;
        float fromValue = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        fromValue = Utils.Remap(fromValue, 0.2f, 1f, 0f, 1f);
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(180, 50, 90), new Microsoft.Xna.Framework.Color(180, 30, 60), amount);
        spriteBatch.Draw(val.Value, vector, rectangle, color * fromValue * num3, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * -1f * (1f - num2), origin, num, effects, 0f);
        Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(255, 240, 150), new Microsoft.Xna.Framework.Color(255, 60, 170), amount);
        Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(255, 255, 80), new Microsoft.Xna.Framework.Color(255, 60, 190), amount);
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.White * num3 * 0.5f;
        color4.A = (byte)((float)(int)color4.A * (1f - fromValue));
        Microsoft.Xna.Framework.Color color5 = color4 * fromValue * 0.5f;
        color5.G = (byte)((float)(int)color5.G * fromValue);
        color5.B = (byte)((float)(int)color5.R * (0.25f + fromValue * 0.75f));
        spriteBatch.Draw(val.Value, vector, rectangle, color5 * 0.15f, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color3 * fromValue * num3 * 0.3f, proj.rotation, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color2 * fromValue * num3 * 0.5f, proj.rotation, origin, num * num4, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.6f * num3, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.5f * num3, proj.rotation + proj.ai[0] * -0.05f, origin, num * 0.8f, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.4f * num3, proj.rotation + proj.ai[0] * -0.1f, origin, num * 0.6f, effects, 0f);
        float num5 = num * 0.75f;
        for (float num6 = 0f; num6 < 12f; num6 += 1f)
        {
            float num7 = proj.rotation + proj.ai[0] * num6 * ((float)Math.PI * -2f) * 0.025f + Utils.Remap(num2, 0f, 0.6f, 0f, 0.95504415f) * proj.ai[0];
            Vector2 drawpos = vector + num7.ToRotationVector2() * ((float)val.Width() * 0.5f - 6f) * num;
            float num8 = num6 / 12f;
            DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * num8, color3, num2, 0f, 0.5f, 0.5f, 1f, num7, new Vector2(0f, Utils.Remap(num2, 0f, 1f, 3f, 0f)) * num5, Vector2.One * num5);
        }
        Vector2 drawpos2 = vector + (proj.rotation + Utils.Remap(num2, 0f, 0.6f, 0f, 0.95504415f) * proj.ai[0]).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * num;
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos2, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * 0.5f, color3, num2, 0f, 0.5f, 0.5f, 1f, 0f, new Vector2(2f, Utils.Remap(num2, 0f, 1f, 4f, 1f)) * num5, Vector2.One * num5);
    }
 
    private void DrawProj_TrueNightsEdge(Projectile proj)
    {
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float num = proj.scale * 1.1f;
        SpriteEffects effects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        float num2 = 0.975f;
        float fromValue = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        fromValue = Utils.Remap(fromValue, 0.2f, 1f, 0f, 1f);
        float num3 = MathHelper.Min(0.15f + fromValue * 0.85f, Utils.Remap(proj.localAI[0], 30f, 96f, 1f, 0f));
        _ = proj.Size / 2f;
        float num4 = 2f;
        for (float num5 = num4; num5 >= 0f; num5 -= 1f)
        {
            if (!(proj.oldPos[(int)num5] == Vector2.Zero))
            {
                Vector2 vector = proj.Center - proj.velocity * 0.5f * num5;
                float num6 = proj.oldRot[(int)num5] + proj.ai[0] * ((float)Math.PI * 2f) * 0.1f * (0f - num5);
                Vector2 position = vector - screenPosition;
                float num7 = 1f - num5 / num4;
                float num8 = proj.Opacity * num7 * num7 * 0.85f;
                float amount = proj.Opacity * proj.Opacity;
                Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(40, 20, 60, 120), new Microsoft.Xna.Framework.Color(80, 160, 50, 120), amount);
                spriteBatch.Draw(val.Value, position, rectangle, color * num3 * num8, num6 + proj.ai[0] * ((float)Math.PI / 4f) * -1f, origin, num * num2, effects, 0f);
                Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(80, 40, 180), new Microsoft.Xna.Framework.Color(155, 255, 100), amount);
                Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.White * num8 * 0.5f;
                color3.A = (byte)((float)(int)color3.A * (1f - num3));
                Microsoft.Xna.Framework.Color color4 = color3 * num3 * 0.5f;
                color4.G = (byte)((float)(int)color4.G * num3);
                color4.R = (byte)((float)(int)color4.R * (0.25f + num3 * 0.75f));
                float num9 = 3f;
                for (float num10 = (float)Math.PI * -2f + (float)Math.PI * 2f / num9; num10 < 0f; num10 += (float)Math.PI * 2f / num9)
                {
                    float num11 = Utils.Remap(num10, (float)Math.PI * -2f, 0f, 0f, 0.5f);
                    spriteBatch.Draw(val.Value, position, rectangle, color4 * 0.15f * num11, num6 + proj.ai[0] * 0.01f + num10, origin, num, effects, 0f);
                    spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(80, 30, 160), new Microsoft.Xna.Framework.Color(200, 255, 0), amount) * fromValue * num8 * num11, num6 + num10, origin, num * 0.8f, effects, 0f);
                    spriteBatch.Draw(val.Value, position, rectangle, color2 * fromValue * num8 * MathHelper.Lerp(0.05f, 0.4f, fromValue) * num11, num6 + num10, origin, num * num2, effects, 0f);
                    spriteBatch.Draw(val.Value, position, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * MathHelper.Lerp(0.05f, 0.5f, fromValue) * num8 * num11, num6 + num10, origin, num, effects, 0f);
                }
                spriteBatch.Draw(val.Value, position, rectangle, color4 * 0.15f, num6 + proj.ai[0] * 0.01f, origin, num, effects, 0f);
                spriteBatch.Draw(val.Value, position, rectangle, Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(80, 30, 160), new Microsoft.Xna.Framework.Color(200, 255, 0), amount) * num3 * num8, num6, origin, num * 0.8f, effects, 0f);
                spriteBatch.Draw(val.Value, position, rectangle, color2 * fromValue * num8 * MathHelper.Lerp(0.05f, 0.4f, num3), num6, origin, num * num2, effects, 0f);
                spriteBatch.Draw(val.Value, position, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * MathHelper.Lerp(0.05f, 0.5f, num3) * num8, num6, origin, num, effects, 0f);
            }
        }
        float num12 = 1f - proj.localAI[0] * 1f / 80f;
        if (num12 < 0.5f)
        {
            num12 = 0.5f;
        }
        Vector2 drawpos = proj.Center - screenPosition + (proj.rotation + 0.47123894f * proj.ai[0]).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * num * num12;
        float num13 = MathHelper.Min(num3, MathHelper.Lerp(1f, fromValue, Utils.Remap(proj.localAI[0], 0f, 80f, 0f, 1f)));
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * proj.Opacity * 0.5f * num13, new Microsoft.Xna.Framework.Color(150, 255, 100) * num13, proj.Opacity, 0f, 1f, 1f, 2f, (float)Math.PI / 4f, new Vector2(2f, 2f), Vector2.One);
    }
 
    private void DrawProj_TerraBlade2(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float num = proj.scale * 1.1f;
        SpriteEffects effects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        float num2 = proj.localAI[0] / proj.ai[1];
        float num3 = Utils.Remap(num2, 0f, 0.6f, 0f, 1f) * Utils.Remap(num2, 0.6f, 1f, 1f, 0f);
        float num4 = 0.975f;
        float num5 = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        num5 = 0.5f + num5 * 0.5f;
        num5 = Utils.Remap(num5, 0.2f, 1f, 0f, 1f);
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(45, 124, 205);
        spriteBatch.Draw(val.Value, vector, rectangle, color * num5 * num3, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * -1f * (1f - num2), origin, num * 0.95f, effects, 0f);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(181, 230, 29);
        Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color(34, 177, 76);
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.White * num3 * 0.5f;
        color4.A = (byte)((float)(int)color4.A * (1f - num5));
        Microsoft.Xna.Framework.Color color5 = color4 * num5 * 0.5f;
        color5.G = (byte)((float)(int)color5.G * num5);
        color5.B = (byte)((float)(int)color5.R * (0.25f + num5 * 0.75f));
        spriteBatch.Draw(val.Value, vector, rectangle, color5 * 0.15f, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color3 * num5 * num3 * 0.3f, proj.rotation, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color2 * num5 * num3 * 0.5f, proj.rotation, origin, num * num4, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.6f * num3, proj.rotation + proj.ai[0] * 0.01f, origin, num, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.5f * num3, proj.rotation + proj.ai[0] * -0.05f, origin, num * 0.8f, effects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.4f * num3, proj.rotation + proj.ai[0] * -0.1f, origin, num * 0.6f, effects, 0f);
        for (float num6 = 0f; num6 < 12f; num6 += 1f)
        {
            float num7 = proj.rotation + proj.ai[0] * (num6 - 2f) * ((float)Math.PI * -2f) * 0.025f + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 4f) * proj.ai[0];
            Vector2 drawpos = vector + num7.ToRotationVector2() * ((float)val.Width() * 0.5f - 6f) * num;
            float num8 = num6 / 12f;
            DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * num8, color3, num2, 0f, 0.5f, 0.5f, 1f, num7, new Vector2(0f, Utils.Remap(num2, 0f, 1f, 3f, 0f)) * num, Vector2.One * num);
        }
        Vector2 drawpos2 = vector + (proj.rotation + Utils.Remap(num2, 0f, 1f, 0f, (float)Math.PI / 4f) * proj.ai[0]).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * num;
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos2, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num3 * 0.5f, color3, num2, 0f, 0.5f, 0.5f, 1f, 0f, new Vector2(2f, Utils.Remap(num2, 0f, 1f, 4f, 1f)) * num, Vector2.One * num * 1.5f);
    }
 
    private void DrawProj_TerraBlade2Shot(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Microsoft.Xna.Framework.Rectangle rectangle = val.Frame(1, 4);
        Vector2 origin = rectangle.Size() / 2f;
        float scale = proj.scale;
        SpriteEffects spriteEffects = ((!(proj.ai[0] >= 0f)) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        SpriteEffects effects = spriteEffects ^ SpriteEffects.FlipVertically;
        float num = Utils.Remap(proj.localAI[0], 0f, proj.ai[1] + 30f, 0f, 1f);
        float opacity = proj.Opacity;
        float num2 = 0.975f;
        float num3 = Lighting.GetColor(proj.Center.ToTileCoordinates()).ToVector3().Length() / (float)Math.Sqrt(3.0);
        num3 = 0.5f + num3 * 0.5f;
        num3 = Utils.Remap(num3, 0.2f, 1f, 0f, 1f);
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(45, 124, 205);
        spriteBatch.Draw(val.Value, vector, rectangle, color * num3 * opacity, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * 0.5f * -1f * (1f - num), origin, scale * 0.95f, spriteEffects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color * num3 * opacity, proj.rotation + proj.ai[0] * ((float)Math.PI / 4f) * 0.5f * 1f * (1f - num), origin, scale * 0.95f, effects, 0f);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(181, 230, 29);
        Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color(34, 177, 76);
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.White * opacity * 0.5f;
        color4.A = (byte)((float)(int)color4.A * (1f - num3));
        Microsoft.Xna.Framework.Color color5 = color4 * num3 * 0.5f;
        color5.G = (byte)((float)(int)color5.G * num3);
        color5.B = (byte)((float)(int)color5.R * (0.25f + num3 * 0.75f));
        spriteBatch.Draw(val.Value, vector, rectangle, color5 * 0.15f, proj.rotation + proj.ai[0] * 0.01f, origin, scale, spriteEffects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color5 * 0.15f, proj.rotation + proj.ai[0] * -0.01f, origin, scale, effects, 0f);
        float num4 = 1f - num;
        float num5 = 0.25f;
        float num6 = 0.15f;
        float num7 = 0.05f;
        spriteBatch.Draw(val.Value, vector, rectangle, color3 * num3 * opacity * 0.3f, proj.rotation + proj.ai[0] * num5 * num4, origin, scale, spriteEffects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color3 * num3 * opacity * 0.3f, proj.rotation + (0f - proj.ai[0]) * num5 * num4, origin, scale, effects, 0f);
        spriteBatch.Draw(val.Value, vector, rectangle, color2 * num3 * opacity * 0.5f, proj.rotation + proj.ai[0] * num6 * num4, origin, scale * num2, spriteEffects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.6f * opacity, proj.rotation + proj.ai[0] * num7 * num4, origin, scale, spriteEffects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.5f * opacity, proj.rotation + proj.ai[0] * -0.05f, origin, scale * 0.8f, spriteEffects, 0f);
        spriteBatch.Draw(val.Value, vector, val.Frame(1, 4, 0, 3), Microsoft.Xna.Framework.Color.White * 0.4f * opacity, proj.rotation + proj.ai[0] * -0.1f, origin, scale * 0.6f, spriteEffects, 0f);
        for (float num8 = -9f; num8 < 9f; num8 += 1f)
        {
            float num9 = proj.rotation + proj.ai[0] * num8 * ((float)Math.PI * -2f) * 0.025f;
            Vector2 drawpos = vector + num9.ToRotationVector2() * ((float)val.Width() * 0.5f - 6f) * scale;
            float num10 = Math.Abs(num8) / 9f;
            DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * opacity * num10, color3, num, 0f, 0.5f, 0.5f, 1f, num9, new Vector2(0f, Utils.Remap(num, 0f, 1f, 3f, 0f)) * scale, Vector2.One * scale);
        }
        for (float num11 = -1f; num11 <= 1f; num11 += 0.5f)
        {
            if (num11 != 0f)
            {
                Vector2 drawpos2 = vector + (proj.rotation + num11 * (float)Math.PI * 0.75f * num).ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * scale;
                float num12 = Utils.Remap(Math.Abs(num11), 0f, 1f, 1f, 0.5f);
                DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos2, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * opacity * 0.5f, color3, num, 0f, 0.5f, 0.5f, 0.75f, (float)Math.PI / 4f, new Vector2(Utils.Remap(num, 0f, 1f, 4f, 1f)) * scale * num12, Vector2.One * scale * num12);
                DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos2, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * opacity * 0.5f, color3, num, 0f, 0.5f, 0.5f, 0.75f, 0f, new Vector2(2f, Utils.Remap(num, 0f, 1f, 4f, 1f)) * scale * num12, Vector2.One * scale * num12);
            }
        }
        Vector2 drawpos3 = vector + proj.rotation.ToRotationVector2() * ((float)val.Width() * 0.5f - 4f) * scale;
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos3, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * opacity * 0.5f, color3, num, 0f, 0.5f, 0.5f, 1f, (float)Math.PI / 4f, new Vector2(Utils.Remap(num, 0f, 1f, 4f, 1f)) * scale, Vector2.One * scale * 1.5f);
        DrawPrettyStarSparkle(proj.Opacity, SpriteEffects.None, drawpos3, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * opacity * 0.5f, color3, num, 0f, 0.5f, 0.5f, 1f, 0f, new Vector2(2f, Utils.Remap(num, 0f, 1f, 4f, 1f)) * scale, Vector2.One * scale * 1.5f);
    }
 
    public void DrawProj(int i)
    {
        int num = ProjectileID.Sets.DrawScreenCheckFluff[projectile[i].type];
        if (new Microsoft.Xna.Framework.Rectangle((int)Camera.ScaledPosition.X - num, (int)Camera.ScaledPosition.Y - num, (int)Camera.ScaledSize.X + num * 2, (int)Camera.ScaledSize.Y + num * 2).Intersects(projectile[i].Hitbox))
        {
            Projectile proj = projectile[i];
            DrawProjDirect(proj);
        }
    }
 
    private void DrawContinuousTrail(Projectile proj)
    {
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(255, 255, 255, 255);
        bool flag = player[proj.owner].cPet == 0;
        DrawTrail(proj, new Vector2(10f, 2f), flag ? new Microsoft.Xna.Framework.Color(177, 255, 32, 127) : color);
        DrawTrail(proj, new Vector2(-10f, 2f), flag ? new Microsoft.Xna.Framework.Color(177, 255, 32, 127) : color);
    }
 
    private static void DrawTrail(Projectile proj, Vector2 rotatableOffsetFromCenter, Microsoft.Xna.Framework.Color baseColor)
    {
        Vector2 vector = proj.Size / 2f;
        Texture2D value = TextureAssets.MagicPixel.Value;
        Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1);
        Vector2[] oldPos = proj.oldPos;
        float[] oldRot = proj.oldRot;
        int num = oldPos.Length;
        for (int num2 = num - 1; num2 > 0; num2--)
        {
            if (!(oldPos[num2] == Vector2.Zero))
            {
                Vector2 vector2 = oldPos[num2] + vector + rotatableOffsetFromCenter.RotatedBy(oldRot[num2]);
                Vector2 v = oldPos[num2 - 1] + vector + rotatableOffsetFromCenter.RotatedBy(oldRot[num2 - 1]) - vector2;
                float y = v.Length();
                float num3 = v.ToRotation();
                float num4 = Utils.Remap(num2, 0f, num, 1f, 0f);
                EntitySpriteDraw(value, vector2 - screenPosition, value2, baseColor * num4, num3 + (float)Math.PI / 2f, new Vector2((float)value2.Width / 2f, value2.Height), new Vector2(4f, y), SpriteEffects.None);
            }
        }
    }
 
    public void DrawProjDirect(Projectile proj)
    {
        PrepareDrawnProjectileDrawing(proj);
        if (proj.type == 734)
        {
            VoidLensHelper voidLensHelper = new VoidLensHelper(proj);
            _voidLensData.Clear();
            int selectionMode = TryInteractingWithVoidLens(proj);
            voidLensHelper.DrawToDrawData(_voidLensData, selectionMode);
            {
                foreach (DrawData voidLensDatum in _voidLensData)
                {
                    EntitySpriteDraw(voidLensDatum);
                }
                return;
            }
        }
        float polePosX = 0f;
        float polePosY = 0f;
        LoadProjectile(proj.type);
        Vector2 mountedCenter = Main.player[proj.owner].MountedCenter;
        if (Main.player[proj.owner].mount.Active && Main.player[proj.owner].mount.Type == 52)
        {
            mountedCenter += new Vector2(Main.player[proj.owner].direction * 14, -10f);
        }
        if (proj.aiStyle == 99)
        {
            Vector2 vector = mountedCenter;
            vector.Y += Main.player[proj.owner].gfxOffY;
            float num = proj.Center.X - vector.X;
            float num2 = proj.Center.Y - vector.Y;
            Math.Sqrt(num * num + num2 * num2);
            float num3 = (float)Math.Atan2(num2, num) - 1.57f;
            if (!proj.counterweight)
            {
                int num4 = -1;
                if (proj.position.X + (float)(proj.width / 2) < Main.player[proj.owner].position.X + (float)(Main.player[proj.owner].width / 2))
                {
                    num4 = 1;
                }
                num4 *= -1;
                Main.player[proj.owner].itemRotation = (float)Math.Atan2(num2 * (float)num4, num * (float)num4);
            }
            bool flag = true;
            bool flag2 = true;
            if (num == 0f && num2 == 0f)
            {
                flag = false;
            }
            else
            {
                float num5 = (float)Math.Sqrt(num * num + num2 * num2);
                num5 = 12f / num5;
                num *= num5;
                num2 *= num5;
                vector.X -= num * 0.1f;
                vector.Y -= num2 * 0.1f;
                num = proj.position.X + (float)proj.width * 0.5f - vector.X;
                num2 = proj.position.Y + (float)proj.height * 0.5f - vector.Y;
            }
            while (flag)
            {
                float num6 = 12f;
                float num7 = (float)Math.Sqrt(num * num + num2 * num2);
                float num8 = num7;
                if (float.IsNaN(num7) || float.IsNaN(num8))
                {
                    flag = false;
                    continue;
                }
                if (num7 < 20f)
                {
                    num6 = num7 - 8f;
                    flag = false;
                }
                num7 = 12f / num7;
                num *= num7;
                num2 *= num7;
                if (flag2)
                {
                    flag2 = false;
                }
                else
                {
                    vector.X += num;
                    vector.Y += num2;
                }
                num = proj.position.X + (float)proj.width * 0.5f - vector.X;
                num2 = proj.position.Y + (float)proj.height * 0.1f - vector.Y;
                if (num8 > 12f)
                {
                    float num9 = 0.3f;
                    float num10 = Math.Abs(proj.velocity.X) + Math.Abs(proj.velocity.Y);
                    if (num10 > 16f)
                    {
                        num10 = 16f;
                    }
                    num10 = 1f - num10 / 16f;
                    num9 *= num10;
                    num10 = num8 / 80f;
                    if (num10 > 1f)
                    {
                        num10 = 1f;
                    }
                    num9 *= num10;
                    if (num9 < 0f)
                    {
                        num9 = 0f;
                    }
                    num9 *= num10;
                    num9 *= 0.5f;
                    if (num2 > 0f)
                    {
                        num2 *= 1f + num9;
                        num *= 1f - num9;
                    }
                    else
                    {
                        num10 = Math.Abs(proj.velocity.X) / 3f;
                        if (num10 > 1f)
                        {
                            num10 = 1f;
                        }
                        num10 -= 0.5f;
                        num9 *= num10;
                        if (num9 > 0f)
                        {
                            num9 *= 2f;
                        }
                        num2 *= 1f + num9;
                        num *= 1f - num9;
                    }
                }
                num3 = (float)Math.Atan2(num2, num) - 1.57f;
                Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
                white.A = (byte)((float)(int)white.A * 0.4f);
                white = TryApplyingPlayerStringColor(Main.player[proj.owner].stringColor, white);
                float num11 = 0.5f;
                white = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f), white);
                EntitySpriteDraw(color: new Microsoft.Xna.Framework.Color((byte)((float)(int)white.R * num11), (byte)((float)(int)white.G * num11), (byte)((float)(int)white.B * num11), (byte)((float)(int)white.A * num11)), texture: TextureAssets.FishingLine.Value, position: new Vector2(vector.X - screenPosition.X + (float)TextureAssets.FishingLine.Width() * 0.5f, vector.Y - screenPosition.Y + (float)TextureAssets.FishingLine.Height() * 0.5f) - new Vector2(6f, 0f), sourceRectangle: new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.FishingLine.Width(), (int)num6), rotation: num3, origin: new Vector2((float)TextureAssets.FishingLine.Width() * 0.5f, 0f), scale: 1f, effects: SpriteEffects.None);
            }
        }
        else
        {
            if (proj.aiStyle == 160)
            {
                DrawKite(proj);
                return;
            }
            if (proj.aiStyle == 165)
            {
                DrawWhip(proj);
                return;
            }
        }
        if (proj.type == 879 || proj.type == 877 || proj.type == 878)
        {
            proj.position.Y -= Main.player[proj.owner].gfxOffY;
        }
        if (proj.aiStyle == 174)
        {
            DrawMultisegmentPet(proj);
            return;
        }
        if (proj.type == 1020)
        {
            DrawContinuousTrail(proj);
        }
        bool flag3 = true;
        switch (proj.type)
        {
        default:
            flag3 = false;
            break;
        case 932:
            DrawProj_FairyQueenRangedItemShot(proj);
            break;
        case 919:
            DrawProj_FairyQueenLance(proj);
            break;
        case 974:
            DrawProj_LightsBane(proj);
            break;
        case 972:
            DrawProj_NightsEdge(proj);
            break;
        case 973:
            DrawProj_TrueNightsEdge(proj);
            break;
        case 982:
            DrawProj_Excalibur(proj);
            break;
        case 997:
            DrawProj_TheHorsemansBlade(proj);
            break;
        case 984:
            DrawProj_TerraBlade2(proj);
            break;
        case 985:
            DrawProj_TerraBlade2Shot(proj);
            break;
        case 983:
            DrawProj_TrueExcalibur(proj);
            break;
        case 995:
            _stardewAnimation.Draw(spriteBatch, (int)proj.ai[0], proj.Center - screenPosition);
            flag3 = false;
            break;
        }
        if (flag3)
        {
            return;
        }
        if (proj.type == 34)
        {
            default(FlameLashDrawer).Draw(proj);
        }
        if (proj.type == 16)
        {
            default(MagicMissileDrawer).Draw(proj);
        }
        if (proj.type == 106)
        {
            default(LightDiscDrawer).Draw(proj);
        }
        if (proj.type == 933)
        {
            default(FinalFractalHelper).Draw(proj);
        }
        if (proj.type == 79)
        {
            default(RainbowRodDrawer).Draw(proj);
        }
        if (proj.type == 946)
        {
            EmpressBladeDrawer empressBladeDrawer = default(EmpressBladeDrawer);
            float num12 = GlobalTimeWrappedHourly % 3f / 3f;
            Player player = Main.player[proj.owner];
            float num13 = MathHelper.Max(1f, player.maxMinions);
            float num14 = (float)proj.identity % num13 / num13 + num12;
            Microsoft.Xna.Framework.Color fairyQueenWeaponsColor = proj.GetFairyQueenWeaponsColor(0f, 0f, num14 % 1f);
            Microsoft.Xna.Framework.Color fairyQueenWeaponsColor2 = proj.GetFairyQueenWeaponsColor(0f, 0f, (num14 + 0.5f) % 1f);
            empressBladeDrawer.ColorStart = fairyQueenWeaponsColor;
            empressBladeDrawer.ColorEnd = fairyQueenWeaponsColor2;
            empressBladeDrawer.Draw(proj);
            DrawProj_EmpressBlade(proj, num14);
            return;
        }
        if (proj.type == 927)
        {
            DrawProj_PiercingStarlight(proj);
            return;
        }
        if (proj.type == 917)
        {
            DrawProj_CoolWhipMinion(proj);
            return;
        }
        if (proj.type == 923)
        {
            Vector2 position = proj.Center - screenPosition;
            Texture2D value = TextureAssets.Projectile[proj.type].Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 2);
            Microsoft.Xna.Framework.Rectangle value2 = value.Frame(1, 2, 0, 1);
            Vector2 origin = rectangle.Size() * new Vector2(0.03f, 0.5f);
            float num15 = 180f;
            float num16 = proj.ai[0] / ((float)Math.PI * 2f) + proj.localAI[0] / num15;
            float num17 = Utils.GetLerpValue(0f, 30f, proj.localAI[0], clamped: true) * Utils.GetLerpValue(num15, num15 - 30f, proj.localAI[0], clamped: true);
            Microsoft.Xna.Framework.Color color2 = hslToRgb(num16 % 1f, 1f, 1f) * num17;
            float lerpValue = Utils.GetLerpValue(40f, 60f, proj.localAI[0], clamped: true);
            Vector2 vector2 = new Vector2(1f, MathHelper.Lerp(0.25f, 0.7f, lerpValue)) * proj.scale;
            Microsoft.Xna.Framework.Color value3 = hslToRgb((num16 + 0.3f) % 1f, 1f, MathHelper.Lerp(0.3f, 0.66f, lerpValue)) * num17;
            if (NPC.ShouldEmpressBeEnraged())
            {
                value3 = OurFavoriteColor * num17;
            }
            value3 = Microsoft.Xna.Framework.Color.Lerp(value3, Microsoft.Xna.Framework.Color.White, 0.1f);
            value3.A /= 2;
            spriteBatch.Draw(value, position, value2, value3, proj.rotation, origin, vector2 * 1.2f, SpriteEffects.None, 0f);
            Microsoft.Xna.Framework.Color value4 = hslToRgb((num16 + 0.15f) % 1f, 1f, MathHelper.Lerp(0.3f, 0.5f, lerpValue)) * num17;
            if (NPC.ShouldEmpressBeEnraged())
            {
                value4 = OurFavoriteColor * num17;
            }
            value4 = Microsoft.Xna.Framework.Color.Lerp(value4, Microsoft.Xna.Framework.Color.White, 0.1f);
            value4.A /= 2;
            spriteBatch.Draw(value, position, value2, value4, proj.rotation, origin, vector2 * 1.1f, SpriteEffects.None, 0f);
            spriteBatch.Draw(value, position, rectangle, color2 * 0.5f, proj.rotation, origin, vector2, SpriteEffects.None, 0f);
            spriteBatch.Draw(value, position, value2, color2 * lerpValue, proj.rotation, origin, vector2, SpriteEffects.None, 0f);
            return;
        }
        if (proj.type == 950)
        {
            Vector2 position2 = proj.Center - screenPosition;
            Texture2D value5 = TextureAssets.Projectile[proj.type].Value;
            Microsoft.Xna.Framework.Rectangle rectangle2 = value5.Frame();
            Vector2 origin2 = rectangle2.Size() * new Vector2(0.5f, 0.5f);
            Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * proj.Opacity;
            float hue = ((proj.ai[2] == 1f) ? 0.96f : 0.92f);
            if (proj.ai[2] == 1f)
            {
                color3 = new Microsoft.Xna.Framework.Color(255, 0, 30, 180) * proj.Opacity;
            }
            Microsoft.Xna.Framework.Color color4 = hslToRgb(hue, 1f, 0.5f) * proj.Opacity;
            color4.A = 0;
            color3 *= 0.6f;
            color4 *= 0.6f;
            float scale = proj.scale;
            float num18 = proj.localAI[0];
            spriteBatch.Draw(value5, position2, rectangle2, color3, proj.rotation, origin2, num18, SpriteEffects.None, 0f);
            spriteBatch.Draw(value5, position2, rectangle2, color4, proj.rotation, origin2, num18 * 0.95f, SpriteEffects.None, 0f);
            spriteBatch.Draw(value5, position2, rectangle2, color3, proj.rotation, origin2, scale, SpriteEffects.None, 0f);
            spriteBatch.Draw(value5, position2, rectangle2, color4, proj.rotation, origin2, scale * 0.95f, SpriteEffects.None, 0f);
            return;
        }
        if (proj.type == 888)
        {
            DrawTwinsPet(proj);
            return;
        }
        if (proj.type == 874)
        {
            DrawMurderAurora(proj);
            return;
        }
        if (proj.type == 871)
        {
            Texture2D value6 = TextureAssets.Projectile[proj.type].Value;
            Microsoft.Xna.Framework.Rectangle rectangle3 = value6.Frame(1, 4);
            Vector2 origin3 = rectangle3.Size() / 2f;
            Microsoft.Xna.Framework.Color color5 = Microsoft.Xna.Framework.Color.White * proj.Opacity;
            SpriteEffects effects = SpriteEffects.None;
            color5.A /= 2;
            Microsoft.Xna.Framework.Color color6 = proj.AI_171_GetColor();
            color6.A /= 2;
            float num19 = proj.scale * 1.3f;
            float num20 = 1f;
            int num21 = proj.AI_172_GetPelletStormsCount();
            bool flag4 = false;
            float num22 = float.PositiveInfinity;
            for (int i = 0; i < num21; i++)
            {
                Projectile.HallowBossPelletStormInfo hallowBossPelletStormInfo = proj.AI_172_GetPelletStormInfo(i);
                for (int j = 0; j < hallowBossPelletStormInfo.BulletsInStorm; j++)
                {
                    float bulletProgress = hallowBossPelletStormInfo.GetBulletProgress(j);
                    if (bulletProgress < num22)
                    {
                        num22 = bulletProgress;
                    }
                    if (hallowBossPelletStormInfo.IsValid(j))
                    {
                        if (i == num21 - 1 && bulletProgress > 0f)
                        {
                            flag4 = true;
                        }
                        rectangle3 = value6.Frame(1, 4, 0, (int)((double)(j + i * 6) + timeForVisualEffects / 4.0) % 4);
                        float num23 = Utils.GetLerpValue(0f, 0.1f, bulletProgress, clamped: true) * Utils.GetLerpValue(1f, 0.8f, bulletProgress, clamped: true);
                        Vector2 bulletPosition = hallowBossPelletStormInfo.GetBulletPosition(j, proj.Center);
                        EntitySpriteDraw(value6, bulletPosition - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle3, color6 * num23, proj.rotation, origin3, num19 * num20, effects);
                        EntitySpriteDraw(value6, bulletPosition - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle3, color5 * num23, proj.rotation, origin3, proj.scale * num20, effects);
                    }
                }
            }
            if (!flag4 && num22 <= 1f)
            {
                EntitySpriteDraw(value6, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle3, color6, proj.rotation, origin3, num19, effects);
                EntitySpriteDraw(value6, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle3, color5, proj.rotation, origin3, proj.scale, effects);
            }
            return;
        }
        if (proj.bobber && Main.player[proj.owner].inventory[Main.player[proj.owner].selectedItem].holdStyle != 0)
        {
            DrawProj_FishingLine(proj, ref polePosX, ref polePosY, mountedCenter);
        }
        else if (proj.type == 32)
        {
            Vector2 vector3 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num24 = mountedCenter.X - vector3.X;
            float num25 = mountedCenter.Y - vector3.Y;
            float rotation = (float)Math.Atan2(num25, num24) - 1.57f;
            bool flag5 = true;
            if (num24 == 0f && num25 == 0f)
            {
                flag5 = false;
            }
            else
            {
                float num26 = (float)Math.Sqrt(num24 * num24 + num25 * num25);
                num26 = 8f / num26;
                num24 *= num26;
                num25 *= num26;
                vector3.X -= num24;
                vector3.Y -= num25;
                num24 = mountedCenter.X - vector3.X;
                num25 = mountedCenter.Y - vector3.Y;
            }
            while (flag5)
            {
                float num27 = (float)Math.Sqrt(num24 * num24 + num25 * num25);
                if (num27 < 28f)
                {
                    flag5 = false;
                    continue;
                }
                if (float.IsNaN(num27))
                {
                    flag5 = false;
                    continue;
                }
                num27 = 28f / num27;
                num24 *= num27;
                num25 *= num27;
                vector3.X += num24;
                vector3.Y += num25;
                num24 = mountedCenter.X - vector3.X;
                num25 = mountedCenter.Y - vector3.Y;
                Microsoft.Xna.Framework.Color color7 = Lighting.GetColor((int)vector3.X / 16, (int)(vector3.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain5.Value, new Vector2(vector3.X - screenPosition.X, vector3.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain5.Width(), TextureAssets.Chain5.Height()), color7, rotation, new Vector2((float)TextureAssets.Chain5.Width() * 0.5f, (float)TextureAssets.Chain5.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 73)
        {
            Vector2 vector4 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num28 = mountedCenter.X - vector4.X;
            float num29 = mountedCenter.Y - vector4.Y;
            float rotation2 = (float)Math.Atan2(num29, num28) - 1.57f;
            bool flag6 = true;
            while (flag6)
            {
                float num30 = (float)Math.Sqrt(num28 * num28 + num29 * num29);
                if (num30 < 25f)
                {
                    flag6 = false;
                    continue;
                }
                if (float.IsNaN(num30))
                {
                    flag6 = false;
                    continue;
                }
                num30 = 12f / num30;
                num28 *= num30;
                num29 *= num30;
                vector4.X += num28;
                vector4.Y += num29;
                num28 = mountedCenter.X - vector4.X;
                num29 = mountedCenter.Y - vector4.Y;
                Microsoft.Xna.Framework.Color color8 = Lighting.GetColor((int)vector4.X / 16, (int)(vector4.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain8.Value, new Vector2(vector4.X - screenPosition.X, vector4.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain8.Width(), TextureAssets.Chain8.Height()), color8, rotation2, new Vector2((float)TextureAssets.Chain8.Width() * 0.5f, (float)TextureAssets.Chain8.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 186)
        {
            Vector2 vector5 = new Vector2(proj.localAI[0], proj.localAI[1]);
            float num31 = Vector2.Distance(proj.Center, vector5) - proj.velocity.Length();
            float num32 = (float)TextureAssets.Chain17.Height() - num31;
            if (num31 > 0f && proj.ai[1] > 0f)
            {
                Microsoft.Xna.Framework.Color color9 = Lighting.GetColor((int)proj.position.X / 16, (int)proj.position.Y / 16);
                EntitySpriteDraw(TextureAssets.Chain17.Value, vector5 - screenPosition, new Microsoft.Xna.Framework.Rectangle(0, (int)num32, TextureAssets.Chain17.Width(), (int)num31), color9, proj.rotation, new Vector2(TextureAssets.Chain17.Width() / 2, 0f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 74)
        {
            Vector2 vector6 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num33 = mountedCenter.X - vector6.X;
            float num34 = mountedCenter.Y - vector6.Y;
            float rotation3 = (float)Math.Atan2(num34, num33) - 1.57f;
            bool flag7 = true;
            while (flag7)
            {
                float num35 = (float)Math.Sqrt(num33 * num33 + num34 * num34);
                if (num35 < 25f)
                {
                    flag7 = false;
                    continue;
                }
                if (float.IsNaN(num35))
                {
                    flag7 = false;
                    continue;
                }
                num35 = 12f / num35;
                num33 *= num35;
                num34 *= num35;
                vector6.X += num33;
                vector6.Y += num34;
                num33 = mountedCenter.X - vector6.X;
                num34 = mountedCenter.Y - vector6.Y;
                Microsoft.Xna.Framework.Color color10 = Lighting.GetColor((int)vector6.X / 16, (int)(vector6.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain9.Value, new Vector2(vector6.X - screenPosition.X, vector6.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain8.Width(), TextureAssets.Chain8.Height()), color10, rotation3, new Vector2((float)TextureAssets.Chain8.Width() * 0.5f, (float)TextureAssets.Chain8.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 171)
        {
            Vector2 vector7 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num36 = 0f - proj.velocity.X;
            float num37 = 0f - proj.velocity.Y;
            float num38 = 1f;
            if (proj.ai[0] <= 17f)
            {
                num38 = proj.ai[0] / 17f;
            }
            int num39 = (int)(30f * num38);
            float num40 = 1f;
            if (proj.ai[0] <= 30f)
            {
                num40 = proj.ai[0] / 30f;
            }
            float num41 = 0.4f * num40;
            float num42 = num41;
            num37 += num42;
            Vector2[] array = new Vector2[num39];
            float[] array2 = new float[num39];
            for (int k = 0; k < num39; k++)
            {
                float num43 = (float)Math.Sqrt(num36 * num36 + num37 * num37);
                float num44 = 5.6f;
                if (Math.Abs(num36) + Math.Abs(num37) < 1f)
                {
                    num44 *= Math.Abs(num36) + Math.Abs(num37) / 1f;
                }
                num43 = num44 / num43;
                num36 *= num43;
                num37 *= num43;
                float num45 = (float)Math.Atan2(num37, num36) - 1.57f;
                array[k].X = vector7.X;
                array[k].Y = vector7.Y;
                array2[k] = num45;
                vector7.X += num36;
                vector7.Y += num37;
                num36 = 0f - proj.velocity.X;
                num37 = 0f - proj.velocity.Y;
                num42 += num41;
                num37 += num42;
            }
            for (int num46 = --num39; num46 >= 0; num46--)
            {
                vector7.X = array[num46].X;
                vector7.Y = array[num46].Y;
                float rotation4 = array2[num46];
                Microsoft.Xna.Framework.Color color11 = Lighting.GetColor((int)vector7.X / 16, (int)(vector7.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain16.Value, new Vector2(vector7.X - screenPosition.X, vector7.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain16.Width(), TextureAssets.Chain16.Height()), color11, rotation4, new Vector2((float)TextureAssets.Chain16.Width() * 0.5f, (float)TextureAssets.Chain16.Height() * 0.5f), 0.8f, SpriteEffects.None);
            }
        }
        else if (proj.type == 475)
        {
            Vector2 vector8 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num47 = 0f - proj.velocity.X;
            float num48 = 0f - proj.velocity.Y;
            float num49 = 1f;
            if (proj.ai[0] <= 17f)
            {
                num49 = proj.ai[0] / 17f;
            }
            int num50 = (int)(30f * num49);
            float num51 = 1f;
            if (proj.ai[0] <= 30f)
            {
                num51 = proj.ai[0] / 30f;
            }
            float num52 = 0.4f * num51;
            float num53 = num52;
            num48 += num53;
            Vector2[] array3 = new Vector2[num50];
            float[] array4 = new float[num50];
            for (int l = 0; l < num50; l++)
            {
                float num54 = (float)Math.Sqrt(num47 * num47 + num48 * num48);
                float num55 = 5.6f;
                if (Math.Abs(num47) + Math.Abs(num48) < 1f)
                {
                    num55 *= Math.Abs(num47) + Math.Abs(num48) / 1f;
                }
                num54 = num55 / num54;
                num47 *= num54;
                num48 *= num54;
                float num56 = (float)Math.Atan2(num48, num47) - 1.57f;
                array3[l].X = vector8.X;
                array3[l].Y = vector8.Y;
                array4[l] = num56;
                vector8.X += num47;
                vector8.Y += num48;
                num47 = 0f - proj.velocity.X;
                num48 = 0f - proj.velocity.Y;
                num53 += num52;
                num48 += num53;
            }
            int num57 = 0;
            for (int num58 = --num50; num58 >= 0; num58--)
            {
                vector8.X = array3[num58].X;
                vector8.Y = array3[num58].Y;
                float rotation5 = array4[num58];
                Microsoft.Xna.Framework.Color color12 = Lighting.GetColor((int)vector8.X / 16, (int)(vector8.Y / 16f));
                if (num57 % 2 == 0)
                {
                    EntitySpriteDraw(TextureAssets.Chain38.Value, new Vector2(vector8.X - screenPosition.X, vector8.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain38.Width(), TextureAssets.Chain38.Height()), color12, rotation5, new Vector2((float)TextureAssets.Chain38.Width() * 0.5f, (float)TextureAssets.Chain38.Height() * 0.5f), 0.8f, SpriteEffects.None);
                }
                else
                {
                    EntitySpriteDraw(TextureAssets.Chain39.Value, new Vector2(vector8.X - screenPosition.X, vector8.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain39.Width(), TextureAssets.Chain39.Height()), color12, rotation5, new Vector2((float)TextureAssets.Chain39.Width() * 0.5f, (float)TextureAssets.Chain39.Height() * 0.5f), 0.8f, SpriteEffects.None);
                }
                num57++;
            }
        }
        else if (proj.type == 505 || proj.type == 506)
        {
            Vector2 vector9 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num59 = 0f - proj.velocity.X;
            float num60 = 0f - proj.velocity.Y;
            float num61 = 1f;
            if (proj.ai[0] <= 17f)
            {
                num61 = proj.ai[0] / 17f;
            }
            int num62 = (int)(30f * num61);
            float num63 = 1f;
            if (proj.ai[0] <= 30f)
            {
                num63 = proj.ai[0] / 30f;
            }
            float num64 = 0.4f * num63;
            float num65 = num64;
            num60 += num65;
            Vector2[] array5 = new Vector2[num62];
            float[] array6 = new float[num62];
            for (int m = 0; m < num62; m++)
            {
                float num66 = (float)Math.Sqrt(num59 * num59 + num60 * num60);
                float num67 = 5.6f;
                if (Math.Abs(num59) + Math.Abs(num60) < 1f)
                {
                    num67 *= Math.Abs(num59) + Math.Abs(num60) / 1f;
                }
                num66 = num67 / num66;
                num59 *= num66;
                num60 *= num66;
                float num68 = (float)Math.Atan2(num60, num59) - 1.57f;
                array5[m].X = vector9.X;
                array5[m].Y = vector9.Y;
                array6[m] = num68;
                vector9.X += num59;
                vector9.Y += num60;
                num59 = 0f - proj.velocity.X;
                num60 = 0f - proj.velocity.Y;
                num65 += num64;
                num60 += num65;
            }
            int num69 = 0;
            for (int num70 = --num62; num70 >= 0; num70--)
            {
                vector9.X = array5[num70].X;
                vector9.Y = array5[num70].Y;
                float rotation6 = array6[num70];
                Microsoft.Xna.Framework.Color color13 = Lighting.GetColor((int)vector9.X / 16, (int)(vector9.Y / 16f));
                int num71 = 4;
                if (proj.type == 506)
                {
                    num71 = 6;
                }
                num71 += num69 % 2;
                EntitySpriteDraw(TextureAssets.Chains[num71].Value, new Vector2(vector9.X - screenPosition.X, vector9.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chains[num71].Width(), TextureAssets.Chains[num71].Height()), color13, rotation6, new Vector2((float)TextureAssets.Chains[num71].Width() * 0.5f, (float)TextureAssets.Chains[num71].Height() * 0.5f), 0.8f, SpriteEffects.None);
                num69++;
            }
        }
        else if (proj.type == 165)
        {
            Vector2 vector10 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num72 = mountedCenter.X - vector10.X;
            float num73 = mountedCenter.Y - vector10.Y;
            float rotation7 = (float)Math.Atan2(num73, num72) - 1.57f;
            bool flag8 = true;
            while (flag8)
            {
                float num74 = (float)Math.Sqrt(num72 * num72 + num73 * num73);
                if (num74 < 25f)
                {
                    flag8 = false;
                    continue;
                }
                if (float.IsNaN(num74))
                {
                    flag8 = false;
                    continue;
                }
                num74 = 24f / num74;
                num72 *= num74;
                num73 *= num74;
                vector10.X += num72;
                vector10.Y += num73;
                num72 = mountedCenter.X - vector10.X;
                num73 = mountedCenter.Y - vector10.Y;
                Microsoft.Xna.Framework.Color color14 = Lighting.GetColor((int)vector10.X / 16, (int)(vector10.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain15.Value, new Vector2(vector10.X - screenPosition.X, vector10.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain15.Width(), TextureAssets.Chain15.Height()), color14, rotation7, new Vector2((float)TextureAssets.Chain15.Width() * 0.5f, (float)TextureAssets.Chain15.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type >= 230 && proj.type <= 235)
        {
            int num75 = proj.type - 229;
            Vector2 vector11 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num76 = mountedCenter.X - vector11.X;
            float num77 = mountedCenter.Y - vector11.Y;
            float rotation8 = (float)Math.Atan2(num77, num76) - 1.57f;
            bool flag9 = true;
            while (flag9)
            {
                float num78 = (float)Math.Sqrt(num76 * num76 + num77 * num77);
                if (num78 < 25f)
                {
                    flag9 = false;
                    continue;
                }
                if (float.IsNaN(num78))
                {
                    flag9 = false;
                    continue;
                }
                num78 = (float)TextureAssets.GemChain[num75].Height() / num78;
                num76 *= num78;
                num77 *= num78;
                vector11.X += num76;
                vector11.Y += num77;
                num76 = mountedCenter.X - vector11.X;
                num77 = mountedCenter.Y - vector11.Y;
                Microsoft.Xna.Framework.Color color15 = Lighting.GetColor((int)vector11.X / 16, (int)(vector11.Y / 16f));
                EntitySpriteDraw(TextureAssets.GemChain[num75].Value, new Vector2(vector11.X - screenPosition.X, vector11.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.GemChain[num75].Width(), TextureAssets.GemChain[num75].Height()), color15, rotation8, new Vector2((float)TextureAssets.GemChain[num75].Width() * 0.5f, (float)TextureAssets.GemChain[num75].Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 753)
        {
            Vector2 vector12 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num79 = mountedCenter.X - vector12.X;
            float num80 = mountedCenter.Y - vector12.Y;
            float rotation9 = (float)Math.Atan2(num80, num79) - 1.57f;
            bool flag10 = true;
            Texture2D value7 = TextureAssets.Extra[95].Value;
            while (flag10)
            {
                float num81 = (float)Math.Sqrt(num79 * num79 + num80 * num80);
                if (num81 < 25f)
                {
                    flag10 = false;
                    continue;
                }
                if (float.IsNaN(num81))
                {
                    flag10 = false;
                    continue;
                }
                num81 = (float)value7.Height / num81;
                num79 *= num81;
                num80 *= num81;
                vector12.X += num79;
                vector12.Y += num80;
                num79 = mountedCenter.X - vector12.X;
                num80 = mountedCenter.Y - vector12.Y;
                Microsoft.Xna.Framework.Color color16 = Lighting.GetColor((int)vector12.X / 16, (int)(vector12.Y / 16f));
                EntitySpriteDraw(value7, new Vector2(vector12.X - screenPosition.X, vector12.Y - screenPosition.Y), null, color16, rotation9, value7.Size() / 2f, 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 865)
        {
            Vector2 vector13 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num82 = mountedCenter.X - vector13.X;
            float num83 = mountedCenter.Y - vector13.Y;
            float rotation10 = (float)Math.Atan2(num83, num82) - 1.57f;
            bool flag11 = true;
            bool flag12 = true;
            Texture2D value8 = TextureAssets.Extra[154].Value;
            while (flag11)
            {
                float num84 = (float)Math.Sqrt(num82 * num82 + num83 * num83);
                if (num84 < 25f)
                {
                    flag11 = false;
                    continue;
                }
                if (float.IsNaN(num84))
                {
                    flag11 = false;
                    continue;
                }
                num84 = (float)value8.Height / num84;
                num82 *= num84;
                num83 *= num84;
                vector13.X += num82;
                vector13.Y += num83;
                num82 = mountedCenter.X - vector13.X;
                num83 = mountedCenter.Y - vector13.Y;
                if (!flag12)
                {
                    Microsoft.Xna.Framework.Color color17 = Lighting.GetColor((int)vector13.X / 16, (int)(vector13.Y / 16f));
                    EntitySpriteDraw(value8, new Vector2(vector13.X - screenPosition.X, vector13.Y - screenPosition.Y), null, color17, rotation10, value8.Size() / 2f, 1f, SpriteEffects.None);
                }
                flag12 = false;
            }
        }
        else if (proj.type == 935)
        {
            Vector2 vector14 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num85 = mountedCenter.X - vector14.X;
            float num86 = mountedCenter.Y - vector14.Y;
            float rotation11 = (float)Math.Atan2(num86, num85) - 1.57f;
            bool flag13 = true;
            bool flag14 = true;
            Texture2D value9 = TextureAssets.Extra[208].Value;
            while (flag13)
            {
                float num87 = (float)Math.Sqrt(num85 * num85 + num86 * num86);
                if (num87 < 8f)
                {
                    flag13 = false;
                    continue;
                }
                if (float.IsNaN(num87))
                {
                    flag13 = false;
                    continue;
                }
                num87 = (float)value9.Height / num87;
                num85 *= num87;
                num86 *= num87;
                vector14.X += num85;
                vector14.Y += num86;
                num85 = mountedCenter.X - vector14.X;
                num86 = mountedCenter.Y - vector14.Y;
                if (!flag14)
                {
                    Microsoft.Xna.Framework.Color color18 = Lighting.GetColor((int)vector14.X / 16, (int)(vector14.Y / 16f));
                    EntitySpriteDraw(value9, new Vector2(vector14.X - screenPosition.X, vector14.Y - screenPosition.Y), null, color18, rotation11, value9.Size() / 2f, 1f, SpriteEffects.None);
                }
                flag14 = false;
            }
        }
        else if (proj.type == 256)
        {
            Vector2 vector15 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num88 = mountedCenter.X - vector15.X;
            float num89 = mountedCenter.Y - vector15.Y;
            float num90 = (float)Math.Atan2(num89, num88) - 1.57f;
            bool flag15 = true;
            while (flag15)
            {
                float num91 = (float)Math.Sqrt(num88 * num88 + num89 * num89);
                if (num91 < 26f)
                {
                    flag15 = false;
                    continue;
                }
                if (float.IsNaN(num91))
                {
                    flag15 = false;
                    continue;
                }
                num91 = 26f / num91;
                num88 *= num91;
                num89 *= num91;
                vector15.X += num88;
                vector15.Y += num89;
                num88 = Main.player[proj.owner].position.X + (float)(Main.player[proj.owner].width / 2) - vector15.X;
                num89 = Main.player[proj.owner].position.Y + (float)(Main.player[proj.owner].height / 2) - vector15.Y;
                Microsoft.Xna.Framework.Color color19 = Lighting.GetColor((int)vector15.X / 16, (int)(vector15.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain20.Value, new Vector2(vector15.X - screenPosition.X, vector15.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain20.Width(), TextureAssets.Chain20.Height()), color19, num90 - 0.785f, new Vector2((float)TextureAssets.Chain20.Width() * 0.5f, (float)TextureAssets.Chain20.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 322)
        {
            Vector2 vector16 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num92 = mountedCenter.X - vector16.X;
            float num93 = mountedCenter.Y - vector16.Y;
            float rotation12 = (float)Math.Atan2(num93, num92) - 1.57f;
            bool flag16 = true;
            while (flag16)
            {
                float num94 = (float)Math.Sqrt(num92 * num92 + num93 * num93);
                if (num94 < 22f)
                {
                    flag16 = false;
                    continue;
                }
                if (float.IsNaN(num94))
                {
                    flag16 = false;
                    continue;
                }
                num94 = 22f / num94;
                num92 *= num94;
                num93 *= num94;
                vector16.X += num92;
                vector16.Y += num93;
                num92 = mountedCenter.X - vector16.X;
                num93 = mountedCenter.Y - vector16.Y;
                Microsoft.Xna.Framework.Color color20 = Lighting.GetColor((int)vector16.X / 16, (int)(vector16.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain29.Value, new Vector2(vector16.X - screenPosition.X, vector16.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain29.Width(), TextureAssets.Chain29.Height()), color20, rotation12, new Vector2((float)TextureAssets.Chain29.Width() * 0.5f, (float)TextureAssets.Chain29.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 315)
        {
            Vector2 vector17 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num95 = mountedCenter.X - vector17.X;
            float num96 = mountedCenter.Y - vector17.Y;
            float rotation13 = (float)Math.Atan2(num96, num95) - 1.57f;
            bool flag17 = true;
            while (flag17)
            {
                float num97 = (float)Math.Sqrt(num95 * num95 + num96 * num96);
                if (num97 < 50f)
                {
                    flag17 = false;
                    continue;
                }
                if (float.IsNaN(num97))
                {
                    flag17 = false;
                    continue;
                }
                num97 = 40f / num97;
                num95 *= num97;
                num96 *= num97;
                vector17.X += num95;
                vector17.Y += num96;
                num95 = mountedCenter.X - vector17.X;
                num96 = mountedCenter.Y - vector17.Y;
                Microsoft.Xna.Framework.Color color21 = Lighting.GetColor((int)vector17.X / 16, (int)(vector17.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain28.Value, new Vector2(vector17.X - screenPosition.X, vector17.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain28.Width(), TextureAssets.Chain28.Height()), color21, rotation13, new Vector2((float)TextureAssets.Chain28.Width() * 0.5f, (float)TextureAssets.Chain28.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 331)
        {
            Vector2 vector18 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num98 = mountedCenter.X - vector18.X;
            float num99 = mountedCenter.Y - vector18.Y;
            float rotation14 = (float)Math.Atan2(num99, num98) - 1.57f;
            bool flag18 = true;
            while (flag18)
            {
                float num100 = (float)Math.Sqrt(num98 * num98 + num99 * num99);
                if (num100 < 30f)
                {
                    flag18 = false;
                    continue;
                }
                if (float.IsNaN(num100))
                {
                    flag18 = false;
                    continue;
                }
                num100 = 24f / num100;
                num98 *= num100;
                num99 *= num100;
                vector18.X += num98;
                vector18.Y += num99;
                num98 = mountedCenter.X - vector18.X;
                num99 = mountedCenter.Y - vector18.Y;
                Microsoft.Xna.Framework.Color color22 = Lighting.GetColor((int)vector18.X / 16, (int)(vector18.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain30.Value, new Vector2(vector18.X - screenPosition.X, vector18.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain30.Width(), TextureAssets.Chain30.Height()), color22, rotation14, new Vector2((float)TextureAssets.Chain30.Width() * 0.5f, (float)TextureAssets.Chain30.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 332)
        {
            int num101 = 0;
            Vector2 vector19 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num102 = mountedCenter.X - vector19.X;
            float num103 = mountedCenter.Y - vector19.Y;
            float rotation15 = (float)Math.Atan2(num103, num102) - 1.57f;
            bool flag19 = true;
            while (flag19)
            {
                float num104 = (float)Math.Sqrt(num102 * num102 + num103 * num103);
                if (num104 < 30f)
                {
                    flag19 = false;
                    continue;
                }
                if (float.IsNaN(num104))
                {
                    flag19 = false;
                    continue;
                }
                int i2 = (int)vector19.X / 16;
                int j2 = (int)vector19.Y / 16;
                if (num101 == 0)
                {
                    Lighting.AddLight(i2, j2, 0f, 0.2f, 0.2f);
                }
                if (num101 == 1)
                {
                    Lighting.AddLight(i2, j2, 0.1f, 0.2f, 0f);
                }
                if (num101 == 2)
                {
                    Lighting.AddLight(i2, j2, 0.2f, 0.1f, 0f);
                }
                if (num101 == 3)
                {
                    Lighting.AddLight(i2, j2, 0.2f, 0f, 0.2f);
                }
                num104 = 16f / num104;
                num102 *= num104;
                num103 *= num104;
                vector19.X += num102;
                vector19.Y += num103;
                num102 = mountedCenter.X - vector19.X;
                num103 = mountedCenter.Y - vector19.Y;
                Microsoft.Xna.Framework.Color color23 = Lighting.GetColor((int)vector19.X / 16, (int)(vector19.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain31.Value, new Vector2(vector19.X - screenPosition.X, vector19.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.Chain31.Height() / 4 * num101, TextureAssets.Chain31.Width(), TextureAssets.Chain31.Height() / 4), color23, rotation15, new Vector2((float)TextureAssets.Chain30.Width() * 0.5f, TextureAssets.Chain30.Height() / 8), 1f, SpriteEffects.None);
                EntitySpriteDraw(TextureAssets.Chain32.Value, new Vector2(vector19.X - screenPosition.X, vector19.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.Chain31.Height() / 4 * num101, TextureAssets.Chain31.Width(), TextureAssets.Chain31.Height() / 4), new Microsoft.Xna.Framework.Color(200, 200, 200, 0), rotation15, new Vector2((float)TextureAssets.Chain30.Width() * 0.5f, TextureAssets.Chain30.Height() / 8), 1f, SpriteEffects.None);
                num101++;
                if (num101 > 3)
                {
                    num101 = 0;
                }
            }
        }
        else if (proj.type == 372 || proj.type == 383 || proj.type == 396 || proj.type == 403 || proj.type == 404 || proj.type == 446 || (proj.type >= 486 && proj.type <= 489) || (proj.type >= 646 && proj.type <= 649) || proj.type == 652)
        {
            Texture2D texture2D = null;
            Microsoft.Xna.Framework.Color color24 = Microsoft.Xna.Framework.Color.Transparent;
            Texture2D value10 = TextureAssets.Chain33.Value;
            if (proj.type == 383)
            {
                value10 = TextureAssets.Chain34.Value;
            }
            if (proj.type == 396)
            {
                value10 = TextureAssets.Chain35.Value;
            }
            if (proj.type == 403)
            {
                value10 = TextureAssets.Chain36.Value;
            }
            if (proj.type == 404)
            {
                value10 = TextureAssets.Chain37.Value;
            }
            if (proj.type == 446)
            {
                value10 = TextureAssets.Extra[3].Value;
            }
            if (proj.type >= 486 && proj.type <= 489)
            {
                value10 = TextureAssets.Chains[proj.type - 486].Value;
            }
            if (proj.type >= 646 && proj.type <= 649)
            {
                value10 = TextureAssets.Chains[proj.type - 646 + 8].Value;
                texture2D = TextureAssets.Chains[proj.type - 646 + 12].Value;
                color24 = new Microsoft.Xna.Framework.Color(255, 255, 255, 127);
            }
            if (proj.type == 652)
            {
                value10 = TextureAssets.Chains[16].Value;
            }
            Vector2 center = proj.Center;
            Microsoft.Xna.Framework.Rectangle? sourceRectangle = null;
            Vector2 origin4 = new Vector2((float)value10.Width * 0.5f, (float)value10.Height * 0.5f);
            float num105 = value10.Height;
            float num106 = 0f;
            if (proj.type == 446)
            {
                int num107 = 7;
                int num108 = (int)proj.localAI[0] / num107;
                sourceRectangle = new Microsoft.Xna.Framework.Rectangle(0, value10.Height / 4 * num108, value10.Width, value10.Height / 4);
                origin4.Y /= 4f;
                num105 /= 4f;
            }
            switch (proj.type)
            {
            case 383:
                num106 = 14f;
                break;
            case 446:
                num106 = 20f;
                break;
            case 489:
                num106 = 10f;
                break;
            case 487:
                num106 = 8f;
                break;
            }
            if (num106 != 0f)
            {
                float num109 = -1.57f;
                Vector2 vector20 = new Vector2((float)Math.Cos(proj.rotation + num109), (float)Math.Sin(proj.rotation + num109));
                center -= vector20 * num106;
                vector20 = mountedCenter - center;
                vector20.Normalize();
                center -= vector20 * num105 / 2f;
            }
            Vector2 vector21 = mountedCenter - center;
            float rotation16 = (float)Math.Atan2(vector21.Y, vector21.X) - 1.57f;
            bool flag20 = true;
            if (float.IsNaN(center.X) && float.IsNaN(center.Y))
            {
                flag20 = false;
            }
            if (float.IsNaN(vector21.X) && float.IsNaN(vector21.Y))
            {
                flag20 = false;
            }
            while (flag20)
            {
                if (vector21.Length() < num105 + 1f)
                {
                    flag20 = false;
                    continue;
                }
                Vector2 vector22 = vector21;
                vector22.Normalize();
                center += vector22 * num105;
                vector21 = mountedCenter - center;
                Microsoft.Xna.Framework.Color color25 = Lighting.GetColor((int)center.X / 16, (int)(center.Y / 16f));
                if (proj.type == 396)
                {
                    color25 *= (float)(255 - proj.alpha) / 255f;
                }
                if (proj.type == 446)
                {
                    color25 = proj.GetAlpha(color25);
                }
                if (proj.type == 488)
                {
                    Lighting.AddLight(center, 0.2f, 0f, 0.175f);
                    color25 = new Microsoft.Xna.Framework.Color(255, 255, 255, 255);
                }
                if (proj.type >= 646 && proj.type <= 649)
                {
                    color25 = proj.GetAlpha(color25);
                }
                EntitySpriteDraw(value10, center - screenPosition, sourceRectangle, color25, rotation16, origin4, 1f, SpriteEffects.None);
                if (texture2D != null)
                {
                    EntitySpriteDraw(texture2D, center - screenPosition, sourceRectangle, color24, rotation16, origin4, 1f, SpriteEffects.None);
                }
            }
        }
        else if (proj.aiStyle == 7)
        {
            Vector2 vector23 = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
            float num110 = mountedCenter.X - vector23.X;
            float num111 = mountedCenter.Y - vector23.Y;
            float rotation17 = (float)Math.Atan2(num111, num110) - 1.57f;
            bool flag21 = true;
            while (flag21)
            {
                float num112 = (float)Math.Sqrt(num110 * num110 + num111 * num111);
                if (num112 < 25f)
                {
                    flag21 = false;
                    continue;
                }
                if (float.IsNaN(num112))
                {
                    flag21 = false;
                    continue;
                }
                num112 = 12f / num112;
                num110 *= num112;
                num111 *= num112;
                vector23.X += num110;
                vector23.Y += num111;
                num110 = mountedCenter.X - vector23.X;
                num111 = mountedCenter.Y - vector23.Y;
                Microsoft.Xna.Framework.Color color26 = Lighting.GetColor((int)vector23.X / 16, (int)(vector23.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain.Value, new Vector2(vector23.X - screenPosition.X, vector23.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain.Width(), TextureAssets.Chain.Height()), color26, rotation17, new Vector2((float)TextureAssets.Chain.Width() * 0.5f, (float)TextureAssets.Chain.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 262)
        {
            float x = proj.Center.X;
            float y = proj.Center.Y;
            float x2 = proj.velocity.X;
            float y2 = proj.velocity.Y;
            float num113 = (float)Math.Sqrt(x2 * x2 + y2 * y2);
            num113 = 4f / num113;
            if (proj.ai[0] == 0f)
            {
                x -= proj.velocity.X * num113;
                y -= proj.velocity.Y * num113;
            }
            else
            {
                x += proj.velocity.X * num113;
                y += proj.velocity.Y * num113;
            }
            Vector2 vector24 = new Vector2(x, y);
            x2 = mountedCenter.X - vector24.X;
            y2 = mountedCenter.Y - vector24.Y;
            float rotation18 = (float)Math.Atan2(y2, x2) - 1.57f;
            if (proj.alpha == 0)
            {
                int num114 = -1;
                if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
                {
                    num114 = 1;
                }
                if (Main.player[proj.owner].direction == 1)
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y2 * (float)num114, x2 * (float)num114);
                }
                else
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y2 * (float)num114, x2 * (float)num114);
                }
            }
            bool flag22 = true;
            while (flag22)
            {
                float num115 = (float)Math.Sqrt(x2 * x2 + y2 * y2);
                if (num115 < 25f)
                {
                    flag22 = false;
                    continue;
                }
                if (float.IsNaN(num115))
                {
                    flag22 = false;
                    continue;
                }
                num115 = 12f / num115;
                x2 *= num115;
                y2 *= num115;
                vector24.X += x2;
                vector24.Y += y2;
                x2 = mountedCenter.X - vector24.X;
                y2 = mountedCenter.Y - vector24.Y;
                Microsoft.Xna.Framework.Color color27 = Lighting.GetColor((int)vector24.X / 16, (int)(vector24.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain22.Value, new Vector2(vector24.X - screenPosition.X, vector24.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain22.Width(), TextureAssets.Chain22.Height()), color27, rotation18, new Vector2((float)TextureAssets.Chain22.Width() * 0.5f, (float)TextureAssets.Chain22.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 273)
        {
            float x3 = proj.Center.X;
            float y3 = proj.Center.Y;
            float x4 = proj.velocity.X;
            float y4 = proj.velocity.Y;
            float num116 = (float)Math.Sqrt(x4 * x4 + y4 * y4);
            num116 = 4f / num116;
            if (proj.ai[0] == 0f)
            {
                x3 -= proj.velocity.X * num116;
                y3 -= proj.velocity.Y * num116;
            }
            else
            {
                x3 += proj.velocity.X * num116;
                y3 += proj.velocity.Y * num116;
            }
            Vector2 vector25 = new Vector2(x3, y3);
            x4 = mountedCenter.X - vector25.X;
            y4 = mountedCenter.Y - vector25.Y;
            float rotation19 = (float)Math.Atan2(y4, x4) - 1.57f;
            if (proj.alpha == 0)
            {
                int num117 = -1;
                if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
                {
                    num117 = 1;
                }
                if (Main.player[proj.owner].direction == 1)
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y4 * (float)num117, x4 * (float)num117);
                }
                else
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y4 * (float)num117, x4 * (float)num117);
                }
            }
            bool flag23 = true;
            while (flag23)
            {
                float num118 = (float)Math.Sqrt(x4 * x4 + y4 * y4);
                if (num118 < 25f)
                {
                    flag23 = false;
                    continue;
                }
                if (float.IsNaN(num118))
                {
                    flag23 = false;
                    continue;
                }
                num118 = 12f / num118;
                x4 *= num118;
                y4 *= num118;
                vector25.X += x4;
                vector25.Y += y4;
                x4 = mountedCenter.X - vector25.X;
                y4 = mountedCenter.Y - vector25.Y;
                Microsoft.Xna.Framework.Color color28 = Lighting.GetColor((int)vector25.X / 16, (int)(vector25.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain23.Value, new Vector2(vector25.X - screenPosition.X, vector25.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain23.Width(), TextureAssets.Chain23.Height()), color28, rotation19, new Vector2((float)TextureAssets.Chain23.Width() * 0.5f, (float)TextureAssets.Chain23.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 481)
        {
            float x5 = proj.Center.X;
            float y5 = proj.Center.Y;
            float x6 = proj.velocity.X;
            float y6 = proj.velocity.Y;
            float num119 = (float)Math.Sqrt(x6 * x6 + y6 * y6);
            num119 = 4f / num119;
            if (proj.ai[0] == 0f)
            {
                x5 -= proj.velocity.X * num119;
                y5 -= proj.velocity.Y * num119;
            }
            else
            {
                x5 += proj.velocity.X * num119;
                y5 += proj.velocity.Y * num119;
            }
            Vector2 origin5 = new Vector2(x5, y5);
            x6 = mountedCenter.X - origin5.X;
            y6 = mountedCenter.Y - origin5.Y;
            float rotation20 = (float)Math.Atan2(y6, x6) - 1.57f;
            if (proj.alpha == 0)
            {
                int num120 = -1;
                if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
                {
                    num120 = 1;
                }
                if (Main.player[proj.owner].direction == 1)
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y6 * (float)num120, x6 * (float)num120);
                }
                else
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y6 * (float)num120, x6 * (float)num120);
                }
            }
            bool flag24 = true;
            while (flag24)
            {
                float num121 = 0.85f;
                float num122 = origin5.Distance(mountedCenter);
                float num123 = num122;
                if ((double)num122 < (double)TextureAssets.Chain40.Height() * 1.5)
                {
                    flag24 = false;
                    continue;
                }
                if (float.IsNaN(num122))
                {
                    flag24 = false;
                    continue;
                }
                num122 = (float)TextureAssets.Chain40.Height() * num121 / num122;
                x6 *= num122;
                y6 *= num122;
                origin5.X += x6;
                origin5.Y += y6;
                x6 = mountedCenter.X - origin5.X;
                y6 = mountedCenter.Y - origin5.Y;
                if (num123 > (float)(TextureAssets.Chain40.Height() * 2))
                {
                    for (int n = 0; n < 2; n++)
                    {
                        float num124 = 0.75f;
                        float num125 = 1f;
                        num125 = ((n != 0) ? Math.Abs(Main.player[proj.owner].velocity.Y) : Math.Abs(Main.player[proj.owner].velocity.X));
                        if (num125 > 10f)
                        {
                            num125 = 10f;
                        }
                        num125 /= 10f;
                        num124 *= num125;
                        num125 = num123 / 80f;
                        if (num125 > 1f)
                        {
                            num125 = 1f;
                        }
                        num124 *= num125;
                        if (num124 < 0f)
                        {
                            num124 = 0f;
                        }
                        if (float.IsNaN(num124))
                        {
                            continue;
                        }
                        if (n == 0)
                        {
                            if (Main.player[proj.owner].velocity.X < 0f && proj.Center.X < mountedCenter.X)
                            {
                                y6 *= 1f - num124;
                            }
                            if (Main.player[proj.owner].velocity.X > 0f && proj.Center.X > mountedCenter.X)
                            {
                                y6 *= 1f - num124;
                            }
                        }
                        else
                        {
                            if (Main.player[proj.owner].velocity.Y < 0f && proj.Center.Y < mountedCenter.Y)
                            {
                                x6 *= 1f - num124;
                            }
                            if (Main.player[proj.owner].velocity.Y > 0f && proj.Center.Y > mountedCenter.Y)
                            {
                                x6 *= 1f - num124;
                            }
                        }
                    }
                }
                Microsoft.Xna.Framework.Color color29 = Lighting.GetColor((int)origin5.X / 16, (int)(origin5.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain40.Value, new Vector2(origin5.X - screenPosition.X, origin5.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain40.Width(), TextureAssets.Chain40.Height()), color29, rotation20, new Vector2((float)TextureAssets.Chain40.Width() * 0.5f, (float)TextureAssets.Chain40.Height() * 0.5f), num121, SpriteEffects.None);
            }
        }
        else if (proj.type == 271)
        {
            float x7 = proj.Center.X;
            float y7 = proj.Center.Y;
            float x8 = proj.velocity.X;
            float y8 = proj.velocity.Y;
            float num126 = (float)Math.Sqrt(x8 * x8 + y8 * y8);
            num126 = 4f / num126;
            if (proj.ai[0] == 0f)
            {
                x7 -= proj.velocity.X * num126;
                y7 -= proj.velocity.Y * num126;
            }
            else
            {
                x7 += proj.velocity.X * num126;
                y7 += proj.velocity.Y * num126;
            }
            Vector2 vector26 = new Vector2(x7, y7);
            x8 = mountedCenter.X - vector26.X;
            y8 = mountedCenter.Y - vector26.Y;
            float rotation21 = (float)Math.Atan2(y8, x8) - 1.57f;
            if (proj.alpha == 0)
            {
                int num127 = -1;
                if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
                {
                    num127 = 1;
                }
                if (Main.player[proj.owner].direction == 1)
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y8 * (float)num127, x8 * (float)num127);
                }
                else
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y8 * (float)num127, x8 * (float)num127);
                }
            }
            bool flag25 = true;
            while (flag25)
            {
                float num128 = (float)Math.Sqrt(x8 * x8 + y8 * y8);
                if (num128 < 25f)
                {
                    flag25 = false;
                    continue;
                }
                if (float.IsNaN(num128))
                {
                    flag25 = false;
                    continue;
                }
                num128 = 12f / num128;
                x8 *= num128;
                y8 *= num128;
                vector26.X += x8;
                vector26.Y += y8;
                x8 = mountedCenter.X - vector26.X;
                y8 = mountedCenter.Y - vector26.Y;
                Microsoft.Xna.Framework.Color color30 = Lighting.GetColor((int)vector26.X / 16, (int)(vector26.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain18.Value, new Vector2(vector26.X - screenPosition.X, vector26.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain18.Width(), TextureAssets.Chain18.Height()), color30, rotation21, new Vector2((float)TextureAssets.Chain18.Width() * 0.5f, (float)TextureAssets.Chain18.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.aiStyle == 13)
        {
            float num129 = proj.position.X + 8f;
            float num130 = proj.position.Y + 2f;
            float x9 = proj.velocity.X;
            float num131 = proj.velocity.Y;
            if (x9 == 0f && num131 == 0f)
            {
                num131 = 0.0001f;
                num131 = 0.0001f;
            }
            float num132 = (float)Math.Sqrt(x9 * x9 + num131 * num131);
            num132 = 20f / num132;
            if (proj.ai[0] == 0f)
            {
                num129 -= proj.velocity.X * num132;
                num130 -= proj.velocity.Y * num132;
            }
            else
            {
                num129 += proj.velocity.X * num132;
                num130 += proj.velocity.Y * num132;
            }
            Vector2 vector27 = new Vector2(num129, num130);
            x9 = mountedCenter.X - vector27.X;
            num131 = mountedCenter.Y - vector27.Y;
            float rotation22 = (float)Math.Atan2(num131, x9) - 1.57f;
            if (proj.alpha == 0)
            {
                int num133 = -1;
                if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
                {
                    num133 = 1;
                }
                if (Main.player[proj.owner].direction == 1)
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(num131 * (float)num133, x9 * (float)num133);
                }
                else
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(num131 * (float)num133, x9 * (float)num133);
                }
            }
            bool flag26 = true;
            while (flag26)
            {
                float num134 = (float)Math.Sqrt(x9 * x9 + num131 * num131);
                if (num134 < 25f)
                {
                    flag26 = false;
                    continue;
                }
                if (float.IsNaN(num134))
                {
                    flag26 = false;
                    continue;
                }
                num134 = 12f / num134;
                x9 *= num134;
                num131 *= num134;
                vector27.X += x9;
                vector27.Y += num131;
                x9 = mountedCenter.X - vector27.X;
                num131 = mountedCenter.Y - vector27.Y;
                Microsoft.Xna.Framework.Color color31 = Lighting.GetColor((int)vector27.X / 16, (int)(vector27.Y / 16f));
                EntitySpriteDraw(TextureAssets.Chain.Value, new Vector2(vector27.X - screenPosition.X, vector27.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain.Width(), TextureAssets.Chain.Height()), color31, rotation22, new Vector2((float)TextureAssets.Chain.Width() * 0.5f, (float)TextureAssets.Chain.Height() * 0.5f), 1f, SpriteEffects.None);
            }
        }
        else if (proj.type == 190)
        {
            float x10 = proj.position.X + (float)(proj.width / 2);
            float y9 = proj.position.Y + (float)(proj.height / 2);
            float x11 = proj.velocity.X;
            float y10 = proj.velocity.Y;
            Math.Sqrt(x11 * x11 + y10 * y10);
            Vector2 vector28 = new Vector2(x10, y9);
            x11 = mountedCenter.X - vector28.X;
            y10 = mountedCenter.Y + Main.player[proj.owner].gfxOffY - vector28.Y;
            Math.Atan2(y10, x11);
            if (proj.alpha == 0)
            {
                int num135 = -1;
                if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
                {
                    num135 = 1;
                }
                if (Main.player[proj.owner].direction == 1)
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y10 * (float)num135, x11 * (float)num135);
                }
                else
                {
                    Main.player[proj.owner].itemRotation = (float)Math.Atan2(y10 * (float)num135, x11 * (float)num135);
                }
            }
        }
        else if (proj.aiStyle == 15)
        {
            DrawProj_FlailChains(proj, mountedCenter);
        }
        Microsoft.Xna.Framework.Color projectileColor = Lighting.GetColor((int)((double)proj.position.X + (double)proj.width * 0.5) / 16, (int)(((double)proj.position.Y + (double)proj.height * 0.5) / 16.0));
        if (proj.hide && !ProjectileID.Sets.DontAttachHideToAlpha[proj.type])
        {
            projectileColor = Lighting.GetColor((int)mountedCenter.X / 16, (int)(mountedCenter.Y / 16f));
        }
        if (proj.type == 14)
        {
            projectileColor = Microsoft.Xna.Framework.Color.White;
        }
        int num136 = 0;
        int num137 = 0;
        if (proj.type == 175)
        {
            num136 = 10;
        }
        if (proj.type == 392)
        {
            num136 = -2;
        }
        if (proj.type == 499)
        {
            num136 = 12;
        }
        if (proj.type == 765)
        {
            num136 = 22;
            num137 = -16;
        }
        if (proj.type == 966)
        {
            num136 = -26;
            num137 = -6;
        }
        if (proj.bobber)
        {
            num136 = 8;
        }
        if (proj.type == 519)
        {
            num136 = 6;
            num137 -= 6;
        }
        if (proj.type == 520)
        {
            num136 = 12;
        }
        if (proj.type == 492)
        {
            num137 -= 4;
            num136 += 5;
        }
        if (proj.type == 498)
        {
            num136 = 6;
        }
        if (proj.type == 489)
        {
            num136 = -2;
        }
        if (proj.type == 486)
        {
            num136 = -6;
        }
        if (proj.type == 525)
        {
            num136 = 5;
        }
        if (proj.type == 488)
        {
            num137 -= 8;
        }
        if (proj.type == 373)
        {
            num137 = -10;
            num136 = 6;
        }
        if (proj.type == 375)
        {
            num137 = -11;
            num136 = 12;
        }
        if (proj.type == 423)
        {
            num137 = -5;
        }
        if (proj.type == 346)
        {
            num136 = 4;
        }
        if (proj.type == 331)
        {
            num137 = -4;
        }
        if (proj.type == 254)
        {
            num136 = 3;
        }
        if (proj.type == 273)
        {
            num137 = 2;
        }
        if (proj.type == 335)
        {
            num136 = 6;
        }
        if (proj.type == 162)
        {
            num136 = 1;
            num137 = 1;
        }
        if (proj.type == 377)
        {
            num136 = -6;
        }
        if (proj.type == 353)
        {
            num136 = 36;
            num137 = -12;
        }
        if (proj.type == 324)
        {
            num136 = 22;
            num137 = -6;
        }
        if (proj.type == 266)
        {
            num136 = 10;
            num137 = -10;
        }
        if (proj.type == 319)
        {
            num136 = 10;
            num137 = -12;
        }
        if (proj.type == 315)
        {
            num136 = -13;
            num137 = -6;
        }
        if (proj.type == 313 && proj.height != 54)
        {
            num137 = -12;
            num136 = 20;
        }
        if (proj.type == 314)
        {
            num137 = -8;
            num136 = 0;
        }
        if (proj.type == 269)
        {
            num136 = 18;
            num137 = -14;
        }
        if (proj.type == 268)
        {
            num136 = 22;
            num137 = -2;
        }
        if (proj.type == 18)
        {
            num136 = 3;
            num137 = 3;
        }
        if (proj.type == 16)
        {
            num136 = 6;
        }
        if (proj.type == 17 || proj.type == 31)
        {
            num136 = 2;
        }
        if (proj.type == 25 || proj.type == 26 || proj.type == 35 || proj.type == 63 || proj.type == 154)
        {
            num136 = 6;
            num137 -= 6;
        }
        if (proj.type == 947 || proj.type == 948)
        {
            num136 = 4;
            num137 -= 4;
        }
        if (proj.type == 28 || proj.type == 37 || proj.type == 75)
        {
            num136 = 8;
        }
        if (proj.type == 29 || proj.type == 470 || proj.type == 637)
        {
            num136 = 11;
        }
        if (proj.type == 43)
        {
            num136 = 4;
        }
        if (proj.type == 208)
        {
            num136 = 2;
            num137 -= 12;
        }
        if (proj.type == 209)
        {
            num136 = 4;
            num137 -= 8;
        }
        if (proj.type == 210)
        {
            num136 = 2;
            num137 -= 22;
        }
        if (proj.type == 251)
        {
            num136 = 18;
            num137 -= 10;
        }
        if (proj.type == 163 || proj.type == 310 || proj.type == 1009 || proj.type == 1010 || proj.type == 1011 || proj.type == 1008)
        {
            num136 = 10;
        }
        if (proj.type == 69 || proj.type == 70)
        {
            num136 = 4;
            num137 = 4;
        }
        float num138 = (float)(TextureAssets.Projectile[proj.type].Width() - proj.width) * 0.5f + (float)proj.width * 0.5f;
        if (proj.type == 50 || proj.type == 53 || proj.type == 515 || proj.type == 870)
        {
            num137 = -8;
        }
        if (proj.type == 473)
        {
            num137 = -6;
            num136 = 2;
        }
        if (proj.type == 72 || proj.type == 86 || proj.type == 87)
        {
            num137 = -16;
            num136 = 8;
        }
        if (proj.type == 74)
        {
            num137 = -6;
        }
        if (proj.type == 99 || proj.type == 727 || proj.type == 1013 || proj.type == 1014)
        {
            num136 = 1;
        }
        if (proj.type == 655)
        {
            num136 = 1;
        }
        if (proj.type == 111)
        {
            num136 = 18;
            num137 = -16;
        }
        if (proj.type == 875)
        {
            num136 = 16;
            num137 = -16;
        }
        if (proj.type == 881)
        {
            num136 = 14;
            num137 = -8;
        }
        if (proj.type == 934)
        {
            num136 = 14;
            num137 = -20;
        }
        if (proj.type == 934)
        {
            num136 = 14;
            num137 = -20;
        }
        if (proj.type == 884)
        {
            num136 = 16;
            num137 = -12;
        }
        if (proj.type == 890)
        {
            num136 = 26;
            num137 = -9;
        }
        if (proj.type == 891)
        {
            num136 = 30;
            num137 = -12;
        }
        if (proj.type == 897)
        {
            num136 = 38;
            num137 = -13;
        }
        if (proj.type == 899)
        {
            num136 = 28;
            num137 = -12;
        }
        if (proj.type == 900)
        {
            num136 = 54;
            num137 = -30;
        }
        if (proj.type == 334)
        {
            num137 = -18;
            num136 = 8;
        }
        if (proj.type == 816)
        {
            num137 = -19;
            num136 = 6;
        }
        if (proj.type == 821)
        {
            num137 = -10;
            num136 = 6;
        }
        if (proj.type == 825)
        {
            num137 = -19;
            num136 = 14;
        }
        if (proj.type == 854)
        {
            num137 = -14;
            num136 = 10;
        }
        if (proj.type == 858)
        {
            num137 = -8;
            num136 = 16;
        }
        if (proj.type == 859)
        {
            num137 = -8;
            num136 = 8;
        }
        if (proj.type == 860)
        {
            num137 = -8;
            num136 = 34;
        }
        if (proj.type == 958)
        {
            num137 = -20;
            num136 = 48;
        }
        if (proj.type == 960)
        {
            num137 = -14;
            num136 = 24;
        }
        if (proj.type == 956)
        {
            num137 = -12;
            num136 = 16;
        }
        if (proj.type == 959)
        {
            num137 = -14 + ((proj.spriteDirection == -1) ? (-8) : 0);
            num136 = 40;
        }
        if (proj.type == 994)
        {
            num137 = -10;
            num136 = 18;
        }
        if (proj.type == 998)
        {
            num137 = -10;
            num136 = 14;
        }
        if (proj.type == 1003)
        {
            num137 = -18 + ((proj.spriteDirection == 1) ? 8 : 0);
            num136 = 22;
        }
        if (proj.type == 1004)
        {
            num137 = -18 + ((proj.spriteDirection == 1) ? 6 : 0);
            num136 = 26;
        }
        if (proj.type == 200)
        {
            num136 = 12;
            num137 = -12;
        }
        if (proj.type == 211)
        {
            num136 = 14;
            num137 = 0;
        }
        if (proj.type == 236)
        {
            num136 = 30;
            num137 = -14;
        }
        if (proj.type >= 191 && proj.type <= 194)
        {
            num136 = 26;
            num137 = ((proj.direction != 1) ? (-22) : (-10));
        }
        if (proj.type >= 390 && proj.type <= 392)
        {
            num137 = 4 * proj.direction;
        }
        if (proj.type == 112)
        {
            num136 = 14;
            num137 = -8 + 4 * proj.spriteDirection;
        }
        _ = proj.type;
        _ = 118;
        if (proj.type == 517 || proj.type == 681)
        {
            num136 = 6;
        }
        if (proj.type == 516)
        {
            num136 = 6;
        }
        if (proj.type == 127)
        {
            num136 = 8;
        }
        if (proj.type == 155)
        {
            num136 = 3;
            num137 = 3;
        }
        if (proj.type == 397)
        {
            num138 -= 1f;
            num136 = -2;
            num137 = -2;
        }
        if (proj.type == 398)
        {
            num136 = 8;
        }
        SpriteEffects dir = SpriteEffects.None;
        if (proj.spriteDirection == -1)
        {
            dir = SpriteEffects.FlipHorizontally;
        }
        if (proj.type == 681 && proj.velocity.X > 0f)
        {
            dir ^= SpriteEffects.FlipHorizontally;
        }
        if (proj.type == 221)
        {
            for (int num139 = 1; num139 < 10; num139++)
            {
                float num140 = proj.velocity.X * (float)num139 * 0.5f;
                float num141 = proj.velocity.Y * (float)num139 * 0.5f;
                Microsoft.Xna.Framework.Color alpha = proj.GetAlpha(projectileColor);
                float num142 = 0f;
                if (num139 == 1)
                {
                    num142 = 0.9f;
                }
                if (num139 == 2)
                {
                    num142 = 0.8f;
                }
                if (num139 == 3)
                {
                    num142 = 0.7f;
                }
                if (num139 == 4)
                {
                    num142 = 0.6f;
                }
                if (num139 == 5)
                {
                    num142 = 0.5f;
                }
                if (num139 == 6)
                {
                    num142 = 0.4f;
                }
                if (num139 == 7)
                {
                    num142 = 0.3f;
                }
                if (num139 == 8)
                {
                    num142 = 0.2f;
                }
                if (num139 == 9)
                {
                    num142 = 0.1f;
                }
                alpha.R = (byte)((float)(int)alpha.R * num142);
                alpha.G = (byte)((float)(int)alpha.G * num142);
                alpha.B = (byte)((float)(int)alpha.B * num142);
                alpha.A = (byte)((float)(int)alpha.A * num142);
                int num143 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y11 = num143 * proj.frame;
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137 - num140, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY - num141), new Microsoft.Xna.Framework.Rectangle(0, y11, TextureAssets.Projectile[proj.type].Width(), num143), alpha, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
            }
        }
        if (proj.type == 408 || proj.type == 435 || proj.type == 436 || proj.type == 438 || proj.type == 452 || proj.type == 454 || proj.type == 459 || proj.type == 462 || proj.type == 503 || proj.type == 532 || proj.type == 533 || proj.type == 573 || proj.type == 582 || proj.type == 585 || proj.type == 592 || proj.type == 601 || proj.type == 636 || proj.type == 638 || proj.type == 640 || proj.type == 639 || proj.type == 424 || proj.type == 425 || proj.type == 426 || proj.type == 660 || proj.type == 661 || proj.type == 671 || proj.type == 664 || proj.type == 666 || proj.type == 668 || proj.type == 675 || proj.type == 680 || proj.type == 682 || proj.type == 684 || proj.type == 686 || proj.type == 700 || proj.type == 706 || proj.type == 709 || proj.type == 710 || proj.type == 711 || proj.type == 261 || ProjectileID.Sets.IsAGolfBall[proj.type] || proj.type == 729 || proj.type == 732 || proj.type == 731 || proj.type == 755 || proj.type == 811 || proj.type == 814 || proj.type == 819 || proj.type == 864 || proj.type == 873 || proj.type == 872 || proj.type == 833 || proj.type == 834 || proj.type == 835 || proj.type == 818 || proj.type == 902 || proj.type == 894 || proj.type == 901 || proj.type == 909 || proj.type == 916 || proj.type == 931 || proj.type == 933 || proj.type == 964 || proj.type == 965 || proj.type == 977 || proj.type == 976 || proj.type == 1001)
        {
            Texture2D value11 = TextureAssets.Projectile[proj.type].Value;
            int num144 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
            int y12 = num144 * proj.frame;
            Microsoft.Xna.Framework.Rectangle rectangle4 = new Microsoft.Xna.Framework.Rectangle(0, y12, value11.Width, num144);
            Vector2 origin6 = rectangle4.Size() / 2f;
            Vector2 zero = Vector2.Zero;
            float num145 = 0f;
            if (proj.type == 503)
            {
                origin6.Y = 70f;
            }
            if (proj.type == 686 || proj.type == 711)
            {
                origin6.Y = rectangle4.Height - 70;
            }
            if (proj.type == 438)
            {
                rectangle4.Y = 0;
            }
            if (proj.type == 452)
            {
                rectangle4.Y = 0;
            }
            if (proj.type == 408)
            {
                rectangle4.Y = num144;
            }
            if (proj.type == 636)
            {
                origin6.Y = 10f;
            }
            if (proj.type == 638)
            {
                origin6.Y = 2f;
            }
            if (proj.type == 640 || proj.type == 639 || proj.type == 710)
            {
                origin6.Y = 5f;
            }
            if (proj.type == 700)
            {
                origin6.X = ((proj.spriteDirection == 1) ? (rectangle4.Width - 20) : 20);
            }
            if (proj.type == 965 || proj.type == 964)
            {
                origin6.X = ((proj.spriteDirection == 1) ? (rectangle4.Width - 20) : 20);
            }
            if (proj.type == 872)
            {
                rectangle4.Width /= 2;
                origin6.X /= 2f;
            }
            if (proj.type == 933)
            {
                int num146 = (int)proj.ai[1];
                if (TextureAssets.Item.IndexInRange(num146))
                {
                    instance.LoadItem(num146);
                    value11 = TextureAssets.Item[num146].Value;
                    rectangle4 = value11.Frame();
                    origin6 = rectangle4.Size() / 2f;
                    num145 = -(float)Math.PI / 4f * (float)proj.spriteDirection;
                }
            }
            if (proj.type == 833 && proj.frame != 8)
            {
                zero.Y += proj.height / 2;
                origin6 = rectangle4.Size() * new Vector2(0.5f, 1f);
                origin6.Y -= 4f;
                origin6.X -= 7 * dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt();
            }
            if ((proj.type == 834 || proj.type == 835) && proj.frame != 10)
            {
                zero.Y += proj.height / 2;
                origin6 = rectangle4.Size() * new Vector2(0.5f, 1f);
                origin6.Y -= 4f;
                origin6.X -= 2 * dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt();
            }
            int num147 = 8;
            int num148 = 2;
            int num149 = 1;
            float value12 = 1f;
            float num150 = 15f;
            float num151 = 0f;
            Microsoft.Xna.Framework.Rectangle value13 = rectangle4;
            UnifiedRandom unifiedRandom = null;
            if (proj.type == 909)
            {
                num149 = 5;
                num147 = 0;
                num148 = -1;
            }
            else if (proj.type == 503)
            {
                num147 = 9;
                num148 = 3;
                value12 = 0.5f;
            }
            else if (proj.type == 261)
            {
                num149 = 18;
                num147 = 0;
                num148 = -2;
                value12 = 1.3f;
            }
            else if (proj.type == 833 || proj.type == 834 || proj.type == 835)
            {
                num149 = 6;
                num147 = 0;
                num148 = -1;
                value12 = 1.5f;
            }
            else if (proj.type == 818)
            {
                num149 = 18;
                num147 = 0;
                num148 = -2;
                value12 = 1f;
            }
            else if (proj.type == 729)
            {
                num149 = 18;
                num147 = 0;
                num148 = -2;
                value12 = 1.3f;
            }
            else if (proj.type == 977)
            {
                num149 = 18;
                num147 = 0;
                num148 = -2;
                value12 = 1.3f;
            }
            else if (proj.type == 1001)
            {
                num149 = 10;
                num147 = 0;
                num148 = -2;
                value12 = 1.3f;
                dir = ((proj.spriteDirection != 1) ? SpriteEffects.FlipVertically : SpriteEffects.None);
            }
            else if (proj.type == 976)
            {
                num149 = 18;
                num147 = 0;
                num148 = -3;
                value12 = 1.3f;
                rectangle4 = new Microsoft.Xna.Framework.Rectangle(0, 20 * proj.frame, 32, 18);
                value13 = rectangle4;
                origin6 = rectangle4.Size() / 2f;
            }
            else if (proj.type == 686 || proj.type == 711)
            {
                num149 = 19;
                num147 = 0;
                num148 = -3;
                value12 = 0.5f;
            }
            else if (ProjectileID.Sets.IsAGolfBall[proj.type])
            {
                num149 = 0;
                num147 = 0;
                num148 = -1;
                value12 = 2f;
            }
            else if (proj.type == 671)
            {
                num149 = 5;
                num147 = 0;
                num148 = -1;
                value12 = 2.6f;
            }
            else if (proj.type == 811)
            {
                num149 = 5;
                num147 = 0;
                num148 = -1;
                value12 = 2.6f;
                projectileColor = Microsoft.Xna.Framework.Color.Lerp(projectileColor, Microsoft.Xna.Framework.Color.White, Utils.Remap(proj.ai[0], 0f, 15f, 1f, 0.3f));
            }
            else if (proj.type == 814)
            {
                num149 = 18;
                num147 = 0;
                num148 = -1;
                value12 = 1f;
                projectileColor = Microsoft.Xna.Framework.Color.Lerp(projectileColor, Microsoft.Xna.Framework.Color.White, 0.35f);
            }
            else if (proj.type == 755)
            {
                num149 = 5;
                num147 = 0;
                num148 = -1;
                value12 = 2.6f;
            }
            else if (proj.type == 700)
            {
                num147 = 5;
                num148 = 1;
                value12 = 2.6f;
            }
            else if (proj.type == 965 || proj.type == 964)
            {
                num147 = 5;
                num148 = 1;
                value12 = 2.6f;
            }
            else if (proj.type == 731)
            {
                num149 = 19;
                num147 = 0;
                num148 = -1;
                value12 = 0.5f;
            }
            else if (proj.type == 864)
            {
                num149 = 12;
                num147 = 0;
                num148 = -1;
                value12 = 1.4f;
                value13.Y += value13.Height;
            }
            else if (proj.type == 916)
            {
                num149 = 19;
                num147 = 0;
                num148 = -1;
                value12 = 1.4f;
                value13.Y += value13.Height;
                unifiedRandom = _tempSeededRandom;
                unifiedRandom.SetSeed(proj.timeLeft);
            }
            else if (proj.type == 873)
            {
                num149 = 39;
                num150 = 40f;
                num147 = 0;
                num148 = -1;
                value12 = 1.4f;
            }
            else if (proj.type == 931)
            {
                num149 = 19;
                num150 = 20f;
                num147 = 0;
                num148 = -1;
                value12 = 0.7f;
            }
            else if (proj.type == 933)
            {
                num149 = 60;
                num150 = 60f;
                num147 = 0;
                num148 = -15;
                value12 = 1f;
            }
            else if (proj.type == 872)
            {
                num149 = 79;
                num150 = 10f;
                num147 = 0;
                num148 = -1;
                value12 = 1f;
                value13.X += value13.Width;
            }
            else if (proj.type == 664 || proj.type == 666 || proj.type == 668)
            {
                num147 = 8;
                num148 = 2;
                value12 = 0.4f;
            }
            else if (proj.type == 582 || proj.type == 902)
            {
                if (proj.ai[2] == 1f)
                {
                    value11 = TextureAssets.Extra[263].Value;
                }
                num147 = 10;
                num148 = 2;
                value12 = 0.7f;
                num151 = 0.2f;
            }
            else if (proj.type == 675)
            {
                num147 = 5;
                num148 = 1;
                value12 = 0.4f;
            }
            else if (proj.type == 638)
            {
                num147 = 5;
                num148 = 1;
                value12 = 1f;
            }
            else if (proj.type == 660)
            {
                num147 = 3;
                num148 = 1;
                value12 = 8f;
                rectangle4 = new Microsoft.Xna.Framework.Rectangle(38 * proj.frame, 0, 38, 38);
                value13 = rectangle4;
                origin6 = rectangle4.Size() / 2f;
            }
            else if (proj.type == 684)
            {
                num147 = 8;
                num148 = 1;
                value12 = 0.75f;
            }
            else if (proj.type == 639)
            {
                num147 = 10;
                num148 = 1;
                value12 = 1f;
            }
            else if (proj.type == 710)
            {
                num149 = 9;
                num147 = 0;
                num148 = -2;
                value12 = 0.5f;
            }
            else if (proj.type == 640)
            {
                num147 = 20;
                num148 = 1;
                value12 = 1f;
            }
            else if (proj.type == 436)
            {
                num148 = 2;
                value12 = 0.5f;
            }
            else if (proj.type == 424 || proj.type == 425 || proj.type == 426)
            {
                num147 = 10;
                num148 = 2;
                value12 = 0.6f;
            }
            else if (proj.type == 438)
            {
                num147 = 10;
                num148 = 2;
                value12 = 1f;
            }
            else if (proj.type == 452)
            {
                num147 = 10;
                num148 = 3;
                value12 = 0.5f;
            }
            else if (proj.type == 454)
            {
                num147 = 5;
                num148 = 1;
                value12 = 0.2f;
            }
            else if (proj.type == 462)
            {
                num147 = 7;
                num148 = 1;
                value12 = 0.2f;
            }
            else if (proj.type == 661)
            {
                num147 = 0;
                num148 = 1;
                value12 = 0.5f;
            }
            else if (proj.type == 706)
            {
                num149 = 9;
                num147 = 0;
                num148 = -2;
                value12 = 0.5f;
            }
            else if (proj.type == 585)
            {
                num147 = 7;
                num148 = 1;
                value12 = 0.2f;
            }
            else if (proj.type == 459)
            {
                num147 = (int)(proj.scale * 8f);
                num148 = num147 / 4;
                if (num148 < 1)
                {
                    num148 = 1;
                }
                value12 = 0.3f;
            }
            else if (proj.type == 709)
            {
                num147 = 8;
                num148 = num147 / 4;
                if (num148 < 1)
                {
                    num148 = 1;
                }
                value12 = 0.5f;
            }
            else if (proj.type == 532)
            {
                num147 = 10;
                num148 = 1;
                value12 = 0.7f;
                num151 = 0.2f;
            }
            else if (proj.type == 592)
            {
                num147 = 10;
                num148 = 2;
                value12 = 1f;
            }
            else if (proj.type == 601)
            {
                num147 = 8;
                num148 = 1;
                value12 = 0.3f;
            }
            else if (proj.type == 636)
            {
                num147 = 20;
                num148 = 3;
                value12 = 0.5f;
            }
            else if (proj.type == 680)
            {
                num147 = 9;
                num148 = 3;
                value12 = 0.5f;
            }
            else if (proj.type == 533)
            {
                if (proj.ai[0] >= 6f && proj.ai[0] <= 8f)
                {
                    num147 = ((proj.ai[0] == 6f) ? 8 : 4);
                    num148 = 1;
                    if (proj.ai[0] != 7f)
                    {
                        num151 = 0.2f;
                    }
                }
                else
                {
                    num147 = (num148 = 0);
                }
            }
            for (int num152 = num149; (num148 > 0 && num152 < num147) || (num148 < 0 && num152 > num147); num152 += num148)
            {
                if (num152 >= proj.oldPos.Length)
                {
                    continue;
                }
                Microsoft.Xna.Framework.Color color32 = projectileColor;
                if (proj.type == 408 || proj.type == 435 || proj.type == 682 || proj.type == 732 || proj.type == 731)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.Blue, 0.5f);
                }
                else if (proj.type == 436)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.LimeGreen, 0.5f);
                }
                else if (proj.type >= 424 && proj.type <= 426)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.Red, 0.5f);
                }
                else if (proj.type == 640 || proj.type == 639)
                {
                    color32.A = 127;
                }
                else if (proj.type == 671)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.Purple, (float)num152 / (float)num147);
                }
                else if (proj.type == 811)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.Crimson * 0.5f, (float)num152 / (float)num147);
                }
                else if (proj.type == 814)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, color32 * 0.5f, (float)num152 / (float)num147);
                }
                else if (proj.type == 261)
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, new Microsoft.Xna.Framework.Color(60, 60, 60, 60), (float)num152 / (float)num147);
                }
                else if (ProjectileID.Sets.IsAGolfBall[proj.type])
                {
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, new Microsoft.Xna.Framework.Color(255, 230, 40, 20), (float)num152 / (float)num147);
                }
                color32 = proj.GetAlpha(color32);
                if (proj.type == 438)
                {
                    color32.G /= (byte)num152;
                    color32.B /= (byte)num152;
                }
                else if (proj.type == 755)
                {
                    color32 = proj.AI_156_GetColor();
                }
                else if (proj.type == 873)
                {
                    color32 = proj.AI_171_GetColor();
                    color32.A /= 2;
                    color32 *= Utils.GetLerpValue(0f, 20f, proj.timeLeft, clamped: true);
                }
                else if (proj.type == 931)
                {
                    color32 = proj.GetFairyQueenWeaponsColor(0.5f);
                    color32 *= Utils.GetLerpValue(0f, 20f, proj.timeLeft, clamped: true);
                }
                else if (proj.type == 872)
                {
                    color32 = proj.AI_173_GetColor();
                    color32 *= 0.4f;
                    color32.A = (byte)((float)(int)color32.A * 0.6f);
                    if (num152 > 80)
                    {
                        color32 *= 0.15f * Utils.GetLerpValue(120f, 80f, num152, clamped: true);
                    }
                }
                else if (proj.type == 864)
                {
                    color32 = proj.GetFloatingDaggerMinionGlowColor();
                    color32.A /= 4;
                }
                else if (proj.type == 682)
                {
                    color32.G /= (byte)num152;
                }
                else if (proj.type == 686)
                {
                    if (proj.oldPos[num152] == Vector2.Zero)
                    {
                        continue;
                    }
                    float num153 = (float)num152 / (float)num149;
                    color32 = ((!(num153 < 0.5f)) ? Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Purple, Microsoft.Xna.Framework.Color.Black, Utils.GetLerpValue(0.5f, 1f, num153)) : Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.Purple, Utils.GetLerpValue(0f, 0.5f, num153)));
                }
                else if (proj.type == 711)
                {
                    if (proj.oldPos[num152] == Vector2.Zero)
                    {
                        continue;
                    }
                    float num154 = (float)num152 / (float)num149;
                    color32 = ((!(num154 < 0.5f)) ? Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(128, 0, 255, 180), Microsoft.Xna.Framework.Color.Black, Utils.GetLerpValue(0.5f, 1f, num154)) : Microsoft.Xna.Framework.Color.Lerp(color32, new Microsoft.Xna.Framework.Color(128, 0, 255, 180), Utils.GetLerpValue(0f, 0.5f, num154)));
                }
                else if (proj.type == 684)
                {
                    if (num152 == 1)
                    {
                        color32.B /= 2;
                        color32.G /= 2;
                        color32.A /= 2;
                    }
                    color32.B /= (byte)num152;
                    color32.G /= (byte)num152;
                    color32.A /= (byte)num152;
                }
                else if (proj.type == 706 || proj.type == 710)
                {
                    color32.B /= (byte)num152;
                    color32.G /= (byte)num152;
                    color32.A /= (byte)num152;
                }
                else if (proj.type == 818)
                {
                    float num155 = 0.3f;
                    float num156 = Utils.GetLerpValue(0f, num155, proj.ai[0], clamped: true) * Utils.GetLerpValue(1f, 1f - num155, proj.ai[0], clamped: true);
                    Utils.GetLerpValue(0f, num148 * -3, num152, clamped: true);
                    Utils.GetLerpValue(num149, num149 + num148 * 3, num152, clamped: true);
                    Microsoft.Xna.Framework.Color value14 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0);
                    Microsoft.Xna.Framework.Color ourFavoriteColor = OurFavoriteColor;
                    ourFavoriteColor.A = 0;
                    ourFavoriteColor *= num156;
                    color32 = Microsoft.Xna.Framework.Color.Lerp(ourFavoriteColor, value14, num156);
                }
                else if (proj.type == 833 || proj.type == 834 || proj.type == 835)
                {
                    float lerpValue2 = Utils.GetLerpValue(0f, 6f, proj.velocity.Length(), clamped: true);
                    color32 = Microsoft.Xna.Framework.Color.Lerp(color32, Microsoft.Xna.Framework.Color.White, lerpValue2 * 0.5f);
                    color32.A = 0;
                    color32 *= lerpValue2;
                }
                else if (proj.type == 592)
                {
                    color32.R /= (byte)num152;
                    color32.G /= (byte)num152;
                }
                else if (proj.type == 640)
                {
                    color32.R /= (byte)num152;
                    color32.A /= (byte)num152;
                }
                else if (proj.type >= 424 && proj.type <= 426)
                {
                    color32.B /= (byte)num152;
                    color32.G /= (byte)num152;
                    color32.A /= (byte)num152;
                }
                else if (proj.type == 964 || proj.type == 965)
                {
                    color32 = Microsoft.Xna.Framework.Color.Black * proj.Opacity;
                }
                float num157 = num147 - num152;
                if (num148 < 0)
                {
                    num157 = num149 - num152;
                }
                color32 *= num157 / ((float)ProjectileID.Sets.TrailCacheLength[proj.type] * 1.5f);
                Vector2 vector29 = proj.oldPos[num152];
                float num158 = proj.rotation;
                SpriteEffects effects2 = dir;
                if (ProjectileID.Sets.TrailingMode[proj.type] == 2 || ProjectileID.Sets.TrailingMode[proj.type] == 3 || ProjectileID.Sets.TrailingMode[proj.type] == 4)
                {
                    num158 = proj.oldRot[num152];
                    effects2 = ((proj.oldSpriteDirection[num152] == -1) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
                }
                if (vector29 == Vector2.Zero)
                {
                    continue;
                }
                if (proj.type == 916)
                {
                    value13.Y += value13.Height;
                    value13.Y %= value13.Height * projFrames[proj.type];
                    _ = num157 / ((float)ProjectileID.Sets.TrailCacheLength[proj.type] * 1.5f);
                    Microsoft.Xna.Framework.Color color33 = new Microsoft.Xna.Framework.Color(0, 0, 0, 255);
                    int num159 = unifiedRandom.Next(3);
                    if (num159 == 2 || num159 == 1)
                    {
                        color33 = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(106, 90, 205, 127), Microsoft.Xna.Framework.Color.Black, 0.2f + 0.8f * unifiedRandom.NextFloat());
                    }
                    color32 = color33;
                    float num160 = num157 / (float)ProjectileID.Sets.TrailCacheLength[proj.type];
                    num160 = Utils.GetLerpValue(0f, (float)ProjectileID.Sets.TrailCacheLength[proj.type] * 0.75f, num157, clamped: true);
                    color32 *= num160;
                    vector29 += unifiedRandom.NextVector2Circular(8f, 8f);
                }
                if (proj.type == 976)
                {
                    int num161 = value13.Height + 2;
                    value13.Y += num161;
                    value13.Y %= num161 * 7;
                    color32 *= Lighting.GetColor((vector29 + zero + proj.Size / 2f).ToTileCoordinates()).ToVector3().Length() / 1.74f;
                }
                if (proj.type == 933)
                {
                    float t = proj.localAI[0] - (float)num152;
                    float num162 = Utils.GetLerpValue(0f, 20f, t, clamped: true) * Utils.GetLerpValue(68f, 60f, t, clamped: true);
                    float lerpValue3 = Utils.GetLerpValue(0f, ProjectileID.Sets.TrailCacheLength[proj.type], num157, clamped: true);
                    color32 = Microsoft.Xna.Framework.Color.White * lerpValue3 * proj.Opacity * num162;
                }
                Vector2 position3 = vector29 + zero + proj.Size / 2f - screenPosition + new Vector2(0f, proj.gfxOffY);
                EntitySpriteDraw(value11, position3, value13, color32, num158 + num145 + proj.rotation * num151 * (float)(num152 - 1) * (float)(-dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt()), origin6, MathHelper.Lerp(proj.scale, value12, (float)num152 / num150), effects2);
            }
            if (proj.type == 661)
            {
                Microsoft.Xna.Framework.Color color34 = new Microsoft.Xna.Framework.Color(120, 40, 222, 120);
                for (int num163 = 0; num163 < 4; num163++)
                {
                    EntitySpriteDraw(TextureAssets.Extra[75].Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI / 2f * (float)num163) * 4f, rectangle4, color34, proj.rotation, origin6, proj.scale, dir);
                }
            }
            if (proj.type == 864)
            {
                Microsoft.Xna.Framework.Color floatingDaggerMinionGlowColor = proj.GetFloatingDaggerMinionGlowColor();
                floatingDaggerMinionGlowColor.A /= 4;
                Microsoft.Xna.Framework.Rectangle value15 = rectangle4;
                value15.Y += value15.Height;
                for (int num164 = 0; num164 < 4; num164++)
                {
                    EntitySpriteDraw(value11, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI / 2f * (float)num164) * 2f, value15, floatingDaggerMinionGlowColor, proj.rotation, origin6, proj.scale, dir);
                }
            }
            if (proj.type == 873 || proj.type == 931)
            {
                Microsoft.Xna.Framework.Color color35 = proj.AI_171_GetColor() * 0.5f;
                color35.A = 0;
                if (proj.type == 931)
                {
                    color35 = proj.GetFairyQueenWeaponsColor(0f);
                }
                Vector2 vector30 = proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY);
                EntitySpriteDraw(value11, vector30, rectangle4, color35, proj.rotation, origin6, proj.scale * 0.9f, dir);
                Texture2D value16 = TextureAssets.Extra[98].Value;
                Microsoft.Xna.Framework.Color color36 = color35;
                Vector2 origin7 = value16.Size() / 2f;
                Microsoft.Xna.Framework.Color color37 = color35 * 0.5f;
                float num165 = Utils.GetLerpValue(15f, 30f, proj.timeLeft, clamped: true) * Utils.GetLerpValue(240f, 200f, proj.timeLeft, clamped: true) * (1f + 0.2f * (float)Math.Cos(GlobalTimeWrappedHourly % 30f / 0.5f * ((float)Math.PI * 2f) * 3f)) * 0.8f;
                Vector2 vector31 = new Vector2(0.5f, 5f) * num165;
                Vector2 vector32 = new Vector2(0.5f, 2f) * num165;
                color36 *= num165;
                color37 *= num165;
                int num166 = 0;
                Vector2 position4 = vector30 + proj.velocity.SafeNormalize(Vector2.Zero) * MathHelper.Lerp(0.5f, 1f, proj.localAI[0] / 60f) * num166;
                if (proj.type == 931)
                {
                    vector31 *= 0.4f;
                    vector32 *= 0.4f;
                }
                EntitySpriteDraw(value16, position4, null, color36, (float)Math.PI / 2f, origin7, vector31, dir);
                EntitySpriteDraw(value16, position4, null, color36, 0f, origin7, vector32, dir);
                EntitySpriteDraw(value16, position4, null, color37, (float)Math.PI / 2f, origin7, vector31 * 0.6f, dir);
                EntitySpriteDraw(value16, position4, null, color37, 0f, origin7, vector32 * 0.6f, dir);
            }
            if (proj.type == 755)
            {
                Microsoft.Xna.Framework.Color color38 = proj.AI_156_GetColor();
                color38.A = 120;
                for (int num167 = 0; num167 < 4; num167++)
                {
                    EntitySpriteDraw(value11, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI / 2f * (float)num167) * 2f, rectangle4, color38, proj.rotation, origin6, proj.scale, dir);
                }
            }
            else if (proj.type == 684)
            {
                float x12 = (proj.localAI[0] * ((float)Math.PI * 2f) / 30f).ToRotationVector2().X;
                Microsoft.Xna.Framework.Color color39 = new Microsoft.Xna.Framework.Color(220, 40, 30, 40);
                color39 *= 0.75f + 0.25f * x12;
                for (int num168 = 0; num168 < 8; num168++)
                {
                    EntitySpriteDraw(value11, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI / 4f * (float)num168) * (4f + 1f * x12), rectangle4, color39, proj.rotation, origin6, proj.scale, dir);
                }
            }
            else if (ProjectileID.Sets.IsAGolfBall[proj.type])
            {
                Player player2 = Main.player[proj.owner];
                bool flag27 = GolfHelper.IsPlayerHoldingClub(player2);
                bool flag28 = false;
                if (flag27)
                {
                    flag28 |= player2.ownedProjectileCounts[722] > 0 && player2.itemAnimation >= player2.itemAnimationMax;
                    flag28 |= player2.itemAnimation == 0;
                    flag28 &= player2.velocity.Y == 0f;
                }
                Vector2 shotVector = MouseWorld - proj.Center;
                if (proj.owner == myPlayer && flag27 && flag28 && GolfHelper.IsGolfBallResting(proj) && GolfHelper.ValidateShot(proj, player2, ref shotVector))
                {
                    projectileColor = Microsoft.Xna.Framework.Color.White;
                    Projectile projectile = null;
                    for (int num169 = 0; num169 < 1000; num169++)
                    {
                        Projectile projectile2 = Main.projectile[num169];
                        if (projectile2.active && projectile2.owner == player2.whoAmI && projectile2.type == 722)
                        {
                            projectile = projectile2;
                            break;
                        }
                    }
                    if (projectile != null)
                    {
                        GolfHelper.ShotStrength shotStrength = GolfHelper.CalculateShotStrength(projectile, proj);
                        Vector2 impactVelocity = Vector2.Normalize(shotVector) * shotStrength.AbsoluteStrength;
                        if (impactVelocity.Length() > 0.05f)
                        {
                            GolfHelper.DrawPredictionLine(proj, impactVelocity, shotStrength.RelativeStrength, shotStrength.RoughLandResistance);
                        }
                    }
                }
                if (!GolfHelper.IsGolfBallResting(proj))
                {
                    Microsoft.Xna.Framework.Color golfTrailColor = Projectile.GetGolfTrailColor(proj);
                    float num170 = proj.velocity.Length() / 16f;
                    if (num170 > 1f)
                    {
                        num170 = 1f;
                    }
                    golfTrailColor *= num170;
                    if (proj.oldPos[4] != Vector2.Zero)
                    {
                        projectileColor = Microsoft.Xna.Framework.Color.White;
                        for (float num171 = 0f; num171 <= 1f; num171 += 0.04f)
                        {
                            EntitySpriteDraw(value11, Vector2.Lerp(proj.oldPos[4], proj.position, num171) + proj.Size / 2f - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, golfTrailColor * num171, proj.rotation, origin6, proj.scale * MathHelper.Lerp(0.7f, 1.5f, num171), dir);
                        }
                    }
                    EntitySpriteDraw(value11, proj.position + proj.Size / 2f - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, golfTrailColor, proj.rotation, origin6, proj.scale * 1.5f, dir);
                }
            }
            if (proj.type == 964 || proj.type == 965)
            {
                Microsoft.Xna.Framework.Color color40 = Microsoft.Xna.Framework.Color.Violet;
                if (proj.type == 965)
                {
                    color40 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Red, Microsoft.Xna.Framework.Color.White, 0.5f);
                }
                Microsoft.Xna.Framework.Color color41 = color40 * 0.5f * proj.Opacity;
                float num172 = ((proj.type == 964) ? 60 : 30);
                for (int num173 = 0; num173 < 4; num173++)
                {
                    EntitySpriteDraw(value11, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) + proj.rotation.ToRotationVector2().RotatedBy(proj.ai[0] / num172 * ((float)Math.PI * 2f) + (float)Math.PI / 2f * (float)num173) * 6f, rectangle4, color41, proj.rotation, origin6, proj.scale, dir);
                }
            }
            Microsoft.Xna.Framework.Color color42 = proj.GetAlpha(projectileColor);
            float num174 = proj.scale;
            float rotation23 = proj.rotation + num145;
            if (proj.type == 640)
            {
                color42 = Microsoft.Xna.Framework.Color.Transparent;
            }
            if (proj.type == 684)
            {
                color42.A = 127;
            }
            if (proj.type == 873)
            {
                color42.A /= 2;
            }
            if (proj.type == 931)
            {
                color42.A /= 2;
            }
            if (proj.type == 872)
            {
                color42 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * proj.Opacity;
                num174 *= 0.9f;
            }
            if (proj.type == 818)
            {
                color42 = Microsoft.Xna.Framework.Color.Transparent;
            }
            if (proj.type == 916)
            {
                color42 = Microsoft.Xna.Framework.Color.Black;
            }
            if (proj.type == 964 || proj.type == 965)
            {
                color42 = Microsoft.Xna.Framework.Color.Black * proj.Opacity;
            }
            if (proj.type == 933)
            {
                float t2 = proj.localAI[0];
                float num175 = Utils.GetLerpValue(0f, 20f, t2, clamped: true) * Utils.GetLerpValue(68f, 60f, t2, clamped: true);
                color42 *= num175;
            }
            EntitySpriteDraw(value11, proj.Center + zero - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, color42, rotation23, origin6, num174, dir);
            if (proj.type == 894)
            {
                float num176 = Utils.WrappedLerp(0.6f, 1f, (float)((int)timeForVisualEffects % 70) / 70f);
                EntitySpriteDraw(color: new Microsoft.Xna.Framework.Color(num176, num176, num176, 150f), texture: TextureAssets.GlowMask[282].Value, position: proj.Center + zero - screenPosition + new Vector2(0f, proj.gfxOffY), sourceRectangle: rectangle4, rotation: proj.rotation, origin: origin6, scale: proj.scale, effects: dir);
            }
            if (proj.type == 503)
            {
                EntitySpriteDraw(TextureAssets.Extra[36].Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, Microsoft.Xna.Framework.Color.White, proj.localAI[0], origin6, proj.scale, dir);
            }
            else if (proj.type == 533)
            {
                EntitySpriteDraw(TextureAssets.GlowMask[128].Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, Microsoft.Xna.Framework.Color.White * 0.3f, proj.rotation, origin6, proj.scale, dir);
            }
            else if (proj.type == 261)
            {
                float num177 = 0.7f;
                float num178 = proj.velocity.Length();
                if (num178 < 0.3f && proj.velocity.Y == 0f)
                {
                    num177 = Utils.GetLerpValue(0.02f, 0.3f, num178, clamped: true) * 0.7f;
                }
                EntitySpriteDraw(TextureAssets.GlowMask[252].Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, Microsoft.Xna.Framework.Color.White * num177, proj.rotation, origin6, proj.scale, dir);
            }
            else if (proj.type == 601)
            {
                Microsoft.Xna.Framework.Color white2 = Microsoft.Xna.Framework.Color.White;
                white2.A = 0;
                EntitySpriteDraw(value11, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, white2, proj.rotation, origin6, proj.scale * 0.7f, dir);
            }
            else if (ProjectileID.Sets.IsAGolfBall[proj.type] && GolfHelper.IsGolfBallResting(proj) && GolfHelper.IsPlayerHoldingClub(LocalPlayer) && GolfHelper.IsGolfShotValid(proj, LocalPlayer) && proj.owner == myPlayer)
            {
                EntitySpriteDraw(TextureAssets.GolfBallOutline.Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, Microsoft.Xna.Framework.Color.White, proj.rotation, origin6, proj.scale, dir);
            }
            if (proj.type == 933)
            {
                float t3 = proj.localAI[0];
                float num179 = Utils.GetLerpValue(0f, 20f, t3, clamped: true) * Utils.GetLerpValue(68f, 60f, t3, clamped: true);
                EntitySpriteDraw(value11, proj.Center + zero - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle4, new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * proj.Opacity * num179, rotation23, origin6, num174 * 1.25f, dir);
                FinalFractalHelper.FinalFractalProfile finalFractalProfile = FinalFractalHelper.GetFinalFractalProfile((int)proj.ai[1]);
                Microsoft.Xna.Framework.Color trailColor = finalFractalProfile.trailColor;
                trailColor.A /= 2;
                DrawPrettyStarSparkle(proj.Opacity, dir, proj.Center + zero - screenPosition + new Vector2(0f, proj.gfxOffY) + (proj.rotation - (float)Math.PI / 2f).ToRotationVector2() * finalFractalProfile.trailWidth, Microsoft.Xna.Framework.Color.White * num179, trailColor * num179, proj.localAI[0], 15f, 30f, 30f, 45f, 0f, new Vector2(5f, 2f), Vector2.One);
            }
        }
        else if (proj.type == 672)
        {
            Vector2 position5 = proj.Center - screenPosition;
            if (proj.localAI[1] == 0f)
            {
                position5.Y += 60f;
                float num180 = proj.localAI[0] / 120f;
                for (int num181 = 0; num181 < 4; num181++)
                {
                    float value17 = num180 * 2f - (float)num181 / 3f;
                    value17 = MathHelper.Clamp(value17, 0f, 1f);
                    float num182 = 1f - MathHelper.Clamp((num180 - 0.8f) / 0.2f, 0f, 1f);
                    EntitySpriteDraw(TextureAssets.MagicPixel.Value, position5, null, new Microsoft.Xna.Framework.Color(0.4f, 0.17f, 0.4f, 0f) * (value17 * num182) * 1.3f, 0f, new Vector2((float)TextureAssets.MagicPixel.Width() / 2f, TextureAssets.MagicPixel.Height()), new Vector2((float)Math.Sqrt(value17) * 100f, value17 * 2f), SpriteEffects.None);
                }
            }
            else if (proj.localAI[1] == 1f)
            {
                _ = proj.localAI[0] / 300f;
                float num183 = Math.Min(1f, proj.localAI[0] / 30f);
                int num184 = (int)(GlobalTimeWrappedHourly * 10f) % 8;
                DrawElderEye(spriteBatch, proj.Center, 1f, 1f, num184, Microsoft.Xna.Framework.Color.White * num183);
                DrawElderEye(spriteBatch, proj.Center, 1f, 1f, (num184 + 1) % 8, new Microsoft.Xna.Framework.Color(0.2f, 0.2f, 0.2f, 0f) * num183);
            }
            else if (proj.localAI[1] == 2f)
            {
                int num185 = (int)(GlobalTimeWrappedHourly * 10f) % 8;
                DrawElderEye(spriteBatch, proj.Center, 1f, 1f, num185, Microsoft.Xna.Framework.Color.White);
                DrawElderEye(spriteBatch, proj.Center, 1f, 1f, (num185 + 1) % 8, new Microsoft.Xna.Framework.Color(0.2f, 0.2f, 0.2f, 0f));
            }
        }
        else
        {
            if (proj.type == 713)
            {
                return;
            }
            if (proj.type == 754)
            {
                Texture2D value18 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle rectangle5 = value18.Frame(5, 2, proj.frame);
                rectangle5.Width -= 2;
                rectangle5.Height -= 2;
                Vector2 origin8 = new Vector2(rectangle5.Width / 2, 0f);
                float y13 = proj.position.Y;
                float num186 = proj.ai[0] + 8f + 2f - (float)rectangle5.Height + 2f;
                Microsoft.Xna.Framework.Color alpha2 = proj.GetAlpha(projectileColor);
                Vector2 top = proj.Top;
                if (proj.ai[1] == 2f)
                {
                    rectangle5 = value18.Frame(5, 2, 4);
                    rectangle5.Width -= 2;
                    rectangle5.Height -= 2;
                    origin8 = new Vector2(rectangle5.Width / 2, 0f);
                    alpha2 = proj.GetAlpha(Lighting.GetColor((int)(top.X + (float)(rectangle5.Width / 2)) / 16, (int)((num186 - 2f + (float)(rectangle5.Height / 2)) / 16f)));
                    EntitySpriteDraw(value18, new Vector2(top.X, num186 - 2f) - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle5, alpha2, proj.rotation, origin8, proj.scale, dir);
                    return;
                }
                for (float num187 = y13; num187 < num186; num187 += (float)rectangle5.Height)
                {
                    Vector2 vector33 = top;
                    vector33.Y = num187;
                    Microsoft.Xna.Framework.Rectangle value19 = rectangle5;
                    float num188 = num186 - num187;
                    if (num188 < (float)value19.Height)
                    {
                        value19.Height = (int)num188;
                    }
                    alpha2 = proj.GetAlpha(Lighting.GetColor((int)(vector33.X + (float)(value19.Width / 2)) / 16, (int)((vector33.Y + (float)(value19.Height / 2)) / 16f)));
                    EntitySpriteDraw(value18, vector33 - screenPosition + new Vector2(0f, proj.gfxOffY), value19, alpha2, proj.rotation, origin8, proj.scale, dir);
                    if (rectangle5.Y == 0)
                    {
                        rectangle5.Y += rectangle5.Height + 2;
                    }
                }
                rectangle5 = value18.Frame(5, 2, 4);
                rectangle5.Width -= 2;
                rectangle5.Height -= 2;
                origin8 = new Vector2(rectangle5.Width / 2, 0f);
                alpha2 = proj.GetAlpha(Lighting.GetColor((int)(top.X + (float)(rectangle5.Width / 2)) / 16, (int)((num186 - 2f + (float)(rectangle5.Height / 2)) / 16f)));
                EntitySpriteDraw(value18, new Vector2(top.X, num186 - 2f) - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle5, alpha2, proj.rotation, origin8, proj.scale, dir);
                return;
            }
            if (proj.type == 12 || proj.type == 728 || proj.type == 955)
            {
                Texture2D value20 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle rectangle6 = new Microsoft.Xna.Framework.Rectangle(0, 0, value20.Width, value20.Height);
                Vector2 origin9 = rectangle6.Size() / 2f;
                Microsoft.Xna.Framework.Color alpha3 = proj.GetAlpha(projectileColor);
                Texture2D value21 = TextureAssets.Extra[91].Value;
                Microsoft.Xna.Framework.Rectangle value22 = value21.Frame();
                Vector2 origin10 = new Vector2((float)value22.Width / 2f, 10f);
                Vector2 vector34 = new Vector2(0f, proj.gfxOffY);
                Vector2 spinningpoint = new Vector2(0f, -10f);
                float num189 = (float)timeForVisualEffects / 60f;
                Vector2 vector35 = proj.Center + proj.velocity;
                Microsoft.Xna.Framework.Color color44 = Microsoft.Xna.Framework.Color.Blue * 0.2f;
                Microsoft.Xna.Framework.Color color45 = Microsoft.Xna.Framework.Color.White * 0.5f;
                color45.A = 0;
                float num190 = 0f;
                if (tenthAnniversaryWorld)
                {
                    color44 = Microsoft.Xna.Framework.Color.HotPink * 0.3f;
                    color45 = Microsoft.Xna.Framework.Color.White * 0.75f;
                    color45.A = 0;
                    num190 = -0.1f;
                }
                if (proj.type == 728)
                {
                    color44 = Microsoft.Xna.Framework.Color.Orange * 0.2f;
                    color45 = Microsoft.Xna.Framework.Color.Gold * 0.5f;
                    color45.A = 50;
                    num190 = -0.2f;
                }
                Microsoft.Xna.Framework.Color color46 = color44;
                color46.A = 0;
                Microsoft.Xna.Framework.Color color47 = color44;
                color47.A = 0;
                Microsoft.Xna.Framework.Color color48 = color44;
                color48.A = 0;
                EntitySpriteDraw(value21, vector35 - screenPosition + vector34 + spinningpoint.RotatedBy((float)Math.PI * 2f * num189), value22, color46, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin10, 1.5f + num190, SpriteEffects.None);
                EntitySpriteDraw(value21, vector35 - screenPosition + vector34 + spinningpoint.RotatedBy((float)Math.PI * 2f * num189 + (float)Math.PI * 2f / 3f), value22, color47, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin10, 1.1f + num190, SpriteEffects.None);
                EntitySpriteDraw(value21, vector35 - screenPosition + vector34 + spinningpoint.RotatedBy((float)Math.PI * 2f * num189 + 4.1887903f), value22, color48, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin10, 1.3f + num190, SpriteEffects.None);
                Vector2 vector36 = proj.Center - proj.velocity * 0.5f;
                for (float num191 = 0f; num191 < 1f; num191 += 0.5f)
                {
                    float num192 = num189 % 0.5f / 0.5f;
                    num192 = (num192 + num191) % 1f;
                    float num193 = num192 * 2f;
                    if (num193 > 1f)
                    {
                        num193 = 2f - num193;
                    }
                    EntitySpriteDraw(value21, vector36 - screenPosition + vector34, value22, color45 * num193, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin10, 0.3f + num192 * 0.5f, SpriteEffects.None);
                }
                EntitySpriteDraw(value20, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle6, alpha3, proj.rotation, origin9, proj.scale + 0.1f, dir);
                return;
            }
            if (proj.type == 756)
            {
                Texture2D value23 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle value24 = value23.Frame(1, 6, 0, proj.frame);
                Vector2 origin11 = new Vector2(16f, value24.Height / 2);
                Microsoft.Xna.Framework.Color alpha4 = proj.GetAlpha(projectileColor);
                Vector2 scale2 = new Vector2(proj.scale);
                float lerpValue4 = Utils.GetLerpValue(35f, 35f - 5f, proj.ai[0], clamped: true);
                scale2.Y *= lerpValue4;
                Vector4 vector37 = projectileColor.ToVector4();
                Vector4 vector38 = new Microsoft.Xna.Framework.Color(67, 17, 17).ToVector4();
                vector38 *= vector37;
                EntitySpriteDraw(TextureAssets.Extra[98].Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) - proj.velocity * proj.scale * 0.5f, null, proj.GetAlpha(new Microsoft.Xna.Framework.Color(vector38.X, vector38.Y, vector38.Z, vector38.W)) * 1f, proj.rotation + (float)Math.PI / 2f, TextureAssets.Extra[98].Value.Size() / 2f, proj.scale * 0.9f, dir);
                EntitySpriteDraw(value23, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), value24, alpha4, proj.rotation, origin11, scale2, dir);
                return;
            }
            if (proj.type == 961)
            {
                Texture2D value25 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle value26 = value25.Frame(1, 5, 0, proj.frame);
                Vector2 origin12 = new Vector2(16f, value26.Height / 2);
                Microsoft.Xna.Framework.Color alpha5 = proj.GetAlpha(projectileColor);
                Vector2 vector39 = new Vector2(proj.scale);
                float lerpValue5 = Utils.GetLerpValue(30f, 25f, proj.ai[0], clamped: true);
                vector39.Y *= lerpValue5;
                Vector4 vector40 = projectileColor.ToVector4();
                Vector4 vector41 = new Microsoft.Xna.Framework.Color(67, 17, 17).ToVector4();
                vector41 *= vector40;
                EntitySpriteDraw(TextureAssets.Extra[98].Value, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) - proj.velocity * proj.scale * 0.5f, null, proj.GetAlpha(new Microsoft.Xna.Framework.Color(vector41.X, vector41.Y, vector41.Z, vector41.W)) * 1f, proj.rotation + (float)Math.PI / 2f, TextureAssets.Extra[98].Value.Size() / 2f, proj.scale * 0.9f, dir);
                Microsoft.Xna.Framework.Color color49 = proj.GetAlpha(Microsoft.Xna.Framework.Color.White) * Utils.Remap(proj.ai[0], 0f, 20f, 0.5f, 0f);
                color49.A = 0;
                for (int num194 = 0; num194 < 4; num194++)
                {
                    EntitySpriteDraw(value25, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY) + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI / 2f * (float)num194) * 2f * vector39, value26, color49, proj.rotation, origin12, vector39, dir);
                }
                EntitySpriteDraw(value25, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), value26, alpha5, proj.rotation, origin12, vector39, dir);
                return;
            }
            if (proj.type == 723 || proj.type == 726 || proj.type == 725 || proj.type == 724 || proj.type == 9)
            {
                Texture2D value27 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle rectangle7 = new Microsoft.Xna.Framework.Rectangle(0, 0, value27.Width, value27.Height);
                Vector2 origin13 = rectangle7.Size() / 2f;
                Microsoft.Xna.Framework.Color color50 = proj.GetAlpha(projectileColor);
                Texture2D value28 = TextureAssets.Extra[91].Value;
                Microsoft.Xna.Framework.Rectangle value29 = value28.Frame();
                Vector2 origin14 = new Vector2((float)value29.Width / 2f, 10f);
                _ = Microsoft.Xna.Framework.Color.White * 0.2f;
                Vector2 vector42 = new Vector2(0f, proj.gfxOffY);
                Vector2 spinningpoint2 = new Vector2(0f, -5f);
                float num195 = (float)timeForVisualEffects / 60f;
                Vector2 vector43 = proj.Center + proj.velocity;
                float num196 = 1.5f;
                float num197 = 1.1f;
                float num198 = 1.3f;
                Microsoft.Xna.Framework.Color color51 = Microsoft.Xna.Framework.Color.Blue * 0.1f;
                Microsoft.Xna.Framework.Color color52 = Microsoft.Xna.Framework.Color.White * 0.3f;
                color52.A = 0;
                byte a = 0;
                float num199 = 1f;
                bool flag29 = true;
                float num200 = proj.scale + 0.1f;
                if (proj.type == 726)
                {
                    Microsoft.Xna.Framework.Color color53 = new Microsoft.Xna.Framework.Color(180, 20, 255);
                    color51 = color53 * 0.3f;
                    color52 = color53 * 0.3f;
                    a = 60;
                    float num201 = 0.6f;
                    num196 -= num201;
                    num197 -= num201;
                    num198 -= num201;
                }
                if (proj.type == 725)
                {
                    Microsoft.Xna.Framework.Color value30 = new Microsoft.Xna.Framework.Color(255, 80, 255);
                    Microsoft.Xna.Framework.Color value31 = new Microsoft.Xna.Framework.Color(255, 255, 0);
                    color51 = Microsoft.Xna.Framework.Color.Lerp(value30, value31, 0.2f) * 0.3f;
                    color52 = Microsoft.Xna.Framework.Color.Lerp(value30, value31, 0.8f) * 0.4f;
                    a = 50;
                    float num202 = 0.5f;
                    num196 -= num202;
                    num197 -= num202;
                    num198 -= num202;
                }
                if (proj.type == 724)
                {
                    Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Black, Microsoft.Xna.Framework.Color.Orange, 0.75f);
                    Microsoft.Xna.Framework.Color color54 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Black, Microsoft.Xna.Framework.Color.Yellow, 0.5f);
                    Microsoft.Xna.Framework.Color value32 = Microsoft.Xna.Framework.Color.Orange * 0.75f;
                    color54 = Microsoft.Xna.Framework.Color.Yellow * 0.5f;
                    color51 = Microsoft.Xna.Framework.Color.Lerp(value32, color54, 0.2f) * 0.3f;
                    color52 = Microsoft.Xna.Framework.Color.Lerp(value32, color54, 0.8f) * 0.4f;
                    a = 0;
                    float num203 = 0.5f;
                    num196 -= num203;
                    num197 -= num203;
                    num198 -= num203;
                }
                if (proj.type == 9)
                {
                    num196 = 0.9f;
                    num197 = 0f;
                    num198 = 0f;
                    flag29 = false;
                    spinningpoint2 = Vector2.Zero;
                    vector42 += proj.velocity.SafeNormalize(Vector2.Zero) * 8f;
                    num199 *= 0.75f;
                    vector43 -= proj.velocity;
                    Microsoft.Xna.Framework.Color value33 = new Microsoft.Xna.Framework.Color(194, 22, 134);
                    value33 *= 0.75f;
                    value33.A /= 2;
                    Microsoft.Xna.Framework.Color value34 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Gold, Microsoft.Xna.Framework.Color.White, 0.5f);
                    value34.A /= 4;
                    value34 *= 0.85f;
                    value34 *= 0.75f;
                    Microsoft.Xna.Framework.Color gold = Microsoft.Xna.Framework.Color.Gold;
                    gold.A = 180;
                    Microsoft.Xna.Framework.Color value35 = new Microsoft.Xna.Framework.Color(194, 22, 134, 127);
                    Microsoft.Xna.Framework.Color value36 = new Microsoft.Xna.Framework.Color(180, 20, 255) * 0.75f * 0.3f;
                    Microsoft.Xna.Framework.Color value37 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.5f * 0.3f;
                    float num204 = 0.5f;
                    float num205 = proj.rotation * num204 % ((float)Math.PI * 2f);
                    if (num205 < 0f)
                    {
                        num205 += (float)Math.PI * 2f;
                    }
                    num205 /= (float)Math.PI * 2f;
                    float num206 = Utils.Remap(num205, 0.15f, 0.5f, 0f, 1f) * Utils.Remap(num205, 0.5f, 0.85f, 1f, 0f);
                    num206 = 1f - num206;
                    color50 = Microsoft.Xna.Framework.Color.Lerp(gold, value35, num206);
                    color51 = Microsoft.Xna.Framework.Color.Lerp(value33, value36, num206);
                    color52 = Microsoft.Xna.Framework.Color.Lerp(value34, value37, num206);
                    num200 += num206 * 0.2f;
                }
                Microsoft.Xna.Framework.Color color55 = color51;
                Microsoft.Xna.Framework.Color color56 = color51;
                Microsoft.Xna.Framework.Color color57 = color51;
                if (flag29)
                {
                    color55.A = a;
                    color56.A = a;
                    color57.A = a;
                }
                EntitySpriteDraw(value28, vector43 - screenPosition + vector42 + spinningpoint2.RotatedBy((float)Math.PI * 2f * num195), value29, color55, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin14, num196, SpriteEffects.None);
                EntitySpriteDraw(value28, vector43 - screenPosition + vector42 + spinningpoint2.RotatedBy((float)Math.PI * 2f * num195 + (float)Math.PI * 2f / 3f), value29, color56, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin14, num197, SpriteEffects.None);
                EntitySpriteDraw(value28, vector43 - screenPosition + vector42 + spinningpoint2.RotatedBy((float)Math.PI * 2f * num195 + 4.1887903f), value29, color57, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin14, num198, SpriteEffects.None);
                Vector2 vector44 = proj.Center - proj.velocity * 0.5f;
                for (float num207 = 0f; num207 < 1f; num207 += 0.5f)
                {
                    float num208 = num195 % 0.5f / 0.5f;
                    num208 = (num208 + num207) % 1f;
                    float num209 = num208 * 2f;
                    if (num209 > 1f)
                    {
                        num209 = 2f - num209;
                    }
                    EntitySpriteDraw(value28, vector44 - screenPosition + vector42, value29, color52 * num209, proj.velocity.ToRotation() + (float)Math.PI / 2f, origin14, (0.5f + num208 * 0.5f) * num199, SpriteEffects.None);
                }
                EntitySpriteDraw(value27, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), rectangle7, color50, proj.rotation, origin13, num200, dir);
                return;
            }
            if (proj.type == 674)
            {
                Texture2D value38 = TextureAssets.Extra[60].Value;
                Vector2 origin15 = new Vector2(66f, 86f);
                Vector2 position6 = proj.Center - screenPosition;
                Vector2 one = Vector2.One;
                one = new Vector2(4f, 1f) * 1.4f;
                Microsoft.Xna.Framework.Color color58 = new Microsoft.Xna.Framework.Color(115, 0, 155, 0);
                Microsoft.Xna.Framework.Color color59 = new Microsoft.Xna.Framework.Color(255, 180, 255, 0);
                float num210 = 0f;
                if (proj.ai[0] < 30f)
                {
                    num210 = Utils.GetLerpValue(0f, 30f, proj.ai[0], clamped: true);
                }
                else if (proj.ai[0] < 40f)
                {
                    num210 = 1f + Utils.GetLerpValue(30f, 40f, proj.ai[0], clamped: true);
                }
                Vector2 vector45 = new Vector2(1f, 1f);
                Vector2 vector46 = new Vector2(0.8f, 2f);
                if (num210 < 1f)
                {
                    vector45.X *= num210;
                }
                one *= num210;
                if (num210 < 1f)
                {
                    color58 *= num210;
                    color59 *= num210;
                }
                if (num210 > 1.5f)
                {
                    float lerpValue6 = Utils.GetLerpValue(2f, 1.5f, num210, clamped: true);
                    color58 *= lerpValue6;
                    color59 *= lerpValue6;
                }
                float num211 = 0.42f;
                color58 *= num211;
                color59 *= num211;
                EntitySpriteDraw(value38, position6, null, color58, 0f, origin15, one * vector45, SpriteEffects.None);
                EntitySpriteDraw(value38, position6, null, color59, 0f, origin15, one * vector46, SpriteEffects.None);
                EntitySpriteDraw(TextureAssets.Extra[59].Value, position6, null, color58, 0f, origin15, one * vector45 * new Vector2(1f, 0.3f), SpriteEffects.None);
                return;
            }
            if (proj.type == 440 || proj.type == 449 || proj.type == 606)
            {
                Microsoft.Xna.Framework.Rectangle value39 = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X - 500, (int)screenPosition.Y - 500, screenWidth + 1000, screenHeight + 1000);
                if (proj.getRect().Intersects(value39))
                {
                    Vector2 vector47 = new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY);
                    float num212 = 100f;
                    float num213 = 3f;
                    if (proj.type == 606)
                    {
                        num212 = 150f;
                        num213 = 3f;
                    }
                    if (proj.ai[1] == 1f)
                    {
                        num212 = (int)proj.localAI[0];
                    }
                    for (int num214 = 1; num214 <= (int)proj.localAI[0]; num214++)
                    {
                        Vector2 vector48 = Vector2.Normalize(proj.velocity) * num214 * num213;
                        Microsoft.Xna.Framework.Color alpha6 = proj.GetAlpha(projectileColor);
                        alpha6 *= (num212 - (float)num214) / num212;
                        alpha6.A = 0;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, vector47 - vector48, null, alpha6, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    }
                }
                return;
            }
            if (proj.type == 85)
            {
                DrawProj_Flamethrower(proj);
                return;
            }
            if (proj.type == 687)
            {
                Vector2 center2 = proj.Center;
                center2 -= screenPosition;
                float num215 = 40f;
                float num216 = num215 * 2f;
                float num217 = (float)proj.frameCounter / num215;
                Texture2D value40 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Color transparent = Microsoft.Xna.Framework.Color.Transparent;
                Microsoft.Xna.Framework.Color color60 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0);
                Microsoft.Xna.Framework.Color color61 = new Microsoft.Xna.Framework.Color(180, 30, 30, 200);
                Microsoft.Xna.Framework.Color color62 = new Microsoft.Xna.Framework.Color(0, 0, 0, 30);
                ulong seed = 1uL;
                for (float num218 = 0f; num218 < 15f; num218 += 1f)
                {
                    float num219 = Utils.RandomFloat(ref seed) * 0.25f - 0.125f;
                    Vector2 vector49 = (proj.rotation + num219).ToRotationVector2();
                    Vector2 value41 = center2 + vector49 * 400f;
                    float num220 = num217 + num218 * (1f / 15f);
                    int num221 = (int)(num220 / (1f / 15f));
                    num220 %= 1f;
                    if ((!(num220 > num217 % 1f) || !((float)proj.frameCounter < num215)) && (!(num220 < num217 % 1f) || !((float)proj.frameCounter >= num216 - num215)))
                    {
                        transparent = ((num220 < 0.1f) ? Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color60, Utils.GetLerpValue(0f, 0.1f, num220, clamped: true)) : ((num220 < 0.35f) ? color60 : ((num220 < 0.7f) ? Microsoft.Xna.Framework.Color.Lerp(color60, color61, Utils.GetLerpValue(0.35f, 0.7f, num220, clamped: true)) : ((num220 < 0.9f) ? Microsoft.Xna.Framework.Color.Lerp(color61, color62, Utils.GetLerpValue(0.7f, 0.9f, num220, clamped: true)) : ((!(num220 < 1f)) ? Microsoft.Xna.Framework.Color.Transparent : Microsoft.Xna.Framework.Color.Lerp(color62, Microsoft.Xna.Framework.Color.Transparent, Utils.GetLerpValue(0.9f, 1f, num220, clamped: true)))))));
                        float num222 = 0.9f + num220 * 0.8f;
                        num222 *= num222;
                        num222 *= 0.8f;
                        Vector2 position7 = Vector2.SmoothStep(center2, value41, num220);
                        Microsoft.Xna.Framework.Rectangle rectangle8 = value40.Frame(1, 7, 0, (int)(num220 * 7f));
                        EntitySpriteDraw(value40, position7, rectangle8, transparent, proj.rotation + (float)Math.PI * 2f * (num220 + GlobalTimeWrappedHourly * 1.2f) * 0.2f + (float)num221 * ((float)Math.PI * 2f / 5f), rectangle8.Size() / 2f, num222, SpriteEffects.None);
                    }
                }
                return;
            }
            if (proj.type == 651)
            {
                if (proj.owner != myPlayer)
                {
                    return;
                }
                Player player3 = Main.player[proj.owner];
                Microsoft.Xna.Framework.Point point = new Vector2(proj.ai[0], proj.ai[1]).ToPoint();
                Microsoft.Xna.Framework.Point point2 = proj.Center.ToTileCoordinates();
                Microsoft.Xna.Framework.Color color63 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0);
                Microsoft.Xna.Framework.Color color64 = new Microsoft.Xna.Framework.Color(127, 127, 127, 0);
                int num223 = 1;
                float num224 = 0f;
                WiresUI.Settings.MultiToolMode toolMode = WiresUI.Settings.ToolMode;
                bool flag30 = toolMode.HasFlag(WiresUI.Settings.MultiToolMode.Actuator);
                if (toolMode.HasFlag(WiresUI.Settings.MultiToolMode.Red))
                {
                    num224 += 1f;
                    color64 = Microsoft.Xna.Framework.Color.Lerp(color64, Microsoft.Xna.Framework.Color.Red, 1f / num224);
                }
                if (toolMode.HasFlag(WiresUI.Settings.MultiToolMode.Blue))
                {
                    num224 += 1f;
                    color64 = Microsoft.Xna.Framework.Color.Lerp(color64, Microsoft.Xna.Framework.Color.Blue, 1f / num224);
                }
                if (toolMode.HasFlag(WiresUI.Settings.MultiToolMode.Green))
                {
                    num224 += 1f;
                    color64 = Microsoft.Xna.Framework.Color.Lerp(color64, new Microsoft.Xna.Framework.Color(0, 255, 0), 1f / num224);
                }
                if (toolMode.HasFlag(WiresUI.Settings.MultiToolMode.Yellow))
                {
                    num224 += 1f;
                    color64 = Microsoft.Xna.Framework.Color.Lerp(color64, new Microsoft.Xna.Framework.Color(255, 255, 0), 1f / num224);
                }
                if (toolMode.HasFlag(WiresUI.Settings.MultiToolMode.Cutter))
                {
                    color63 = new Microsoft.Xna.Framework.Color(50, 50, 50, 255);
                }
                color64.A = 0;
                if (point == point2)
                {
                    Vector2 position8 = point2.ToVector2() * 16f - screenPosition;
                    Microsoft.Xna.Framework.Rectangle value42 = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
                    if (flag30)
                    {
                        EntitySpriteDraw(TextureAssets.WireUi[11].Value, position8, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position8, value42, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    value42.Y = 18;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position8, value42, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    return;
                }
                if (point.X == point2.X)
                {
                    int num225 = point2.Y - point.Y;
                    int num226 = Math.Sign(num225);
                    Vector2 position9 = point.ToVector2() * 16f - screenPosition;
                    Microsoft.Xna.Framework.Rectangle value43 = new Microsoft.Xna.Framework.Rectangle((num225 * num223 > 0) ? 72 : 18, 0, 16, 16);
                    if (flag30)
                    {
                        EntitySpriteDraw(TextureAssets.WireUi[11].Value, position9, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position9, value43, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    value43.Y = 18;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position9, value43, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    for (int num227 = point.Y + num226; num227 != point2.Y; num227 += num226)
                    {
                        position9 = new Vector2(point.X * 16, num227 * 16) - screenPosition;
                        value43.Y = 0;
                        value43.X = 90;
                        if (flag30)
                        {
                            EntitySpriteDraw(TextureAssets.WireUi[11].Value, position9, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        }
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position9, value43, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        value43.Y = 18;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position9, value43, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    position9 = point2.ToVector2() * 16f - screenPosition;
                    value43 = new Microsoft.Xna.Framework.Rectangle((num225 * num223 > 0) ? 18 : 72, 0, 16, 16);
                    if (flag30)
                    {
                        EntitySpriteDraw(TextureAssets.WireUi[11].Value, position9, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position9, value43, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    value43.Y = 18;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position9, value43, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    return;
                }
                if (point.Y == point2.Y)
                {
                    int num228 = point2.X - point.X;
                    int num229 = Math.Sign(num228);
                    Vector2 position10 = point.ToVector2() * 16f - screenPosition;
                    Microsoft.Xna.Framework.Rectangle value44 = new Microsoft.Xna.Framework.Rectangle((num228 > 0) ? 36 : 144, 0, 16, 16);
                    if (flag30)
                    {
                        EntitySpriteDraw(TextureAssets.WireUi[11].Value, position10, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position10, value44, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    value44.Y = 18;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position10, value44, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    for (int num230 = point.X + num229; num230 != point2.X; num230 += num229)
                    {
                        position10 = new Vector2(num230 * 16, point.Y * 16) - screenPosition;
                        value44.Y = 0;
                        value44.X = 180;
                        if (flag30)
                        {
                            EntitySpriteDraw(TextureAssets.WireUi[11].Value, position10, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        }
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position10, value44, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        value44.Y = 18;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position10, value44, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    position10 = point2.ToVector2() * 16f - screenPosition;
                    value44 = new Microsoft.Xna.Framework.Rectangle((num228 > 0) ? 144 : 36, 0, 16, 16);
                    if (flag30)
                    {
                        EntitySpriteDraw(TextureAssets.WireUi[11].Value, position10, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position10, value44, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    value44.Y = 18;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position10, value44, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    return;
                }
                Math.Abs(point.X - point2.X);
                Math.Abs(point.Y - point2.Y);
                int num231 = Math.Sign(point2.X - point.X);
                int num232 = Math.Sign(point2.Y - point.Y);
                Microsoft.Xna.Framework.Point p = default(Microsoft.Xna.Framework.Point);
                bool flag31 = false;
                bool flag32 = player3.direction == 1;
                int num233;
                int num234;
                int num235;
                if (flag32)
                {
                    p.X = point.X;
                    num233 = point.Y;
                    num234 = point2.Y;
                    num235 = num232;
                }
                else
                {
                    p.Y = point.Y;
                    num233 = point.X;
                    num234 = point2.X;
                    num235 = num231;
                }
                Vector2 position11 = point.ToVector2() * 16f - screenPosition;
                Microsoft.Xna.Framework.Rectangle value45 = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
                if (!flag32)
                {
                    value45.X = ((num235 > 0) ? 36 : 144);
                }
                else
                {
                    value45.X = ((num235 > 0) ? 72 : 18);
                }
                if (flag30)
                {
                    EntitySpriteDraw(TextureAssets.WireUi[11].Value, position11, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                }
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                value45.Y = 18;
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                for (int num236 = num233 + num235; num236 != num234; num236 += num235)
                {
                    if (flag31)
                    {
                        break;
                    }
                    if (flag32)
                    {
                        p.Y = num236;
                    }
                    else
                    {
                        p.X = num236;
                    }
                    if (WorldGen.InWorld(p.X, p.Y, 1) && tile[p.X, p.Y] != null)
                    {
                        position11 = p.ToVector2() * 16f - screenPosition;
                        value45.Y = 0;
                        if (!flag32)
                        {
                            value45.X = 180;
                        }
                        else
                        {
                            value45.X = 90;
                        }
                        if (flag30)
                        {
                            EntitySpriteDraw(TextureAssets.WireUi[11].Value, position11, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        }
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        value45.Y = 18;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                }
                if (flag32)
                {
                    p.Y = point2.Y;
                    num233 = point.X;
                    num234 = point2.X;
                    num235 = num231;
                }
                else
                {
                    p.X = point2.X;
                    num233 = point.Y;
                    num234 = point2.Y;
                    num235 = num232;
                }
                position11 = p.ToVector2() * 16f - screenPosition;
                value45 = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
                if (!flag32)
                {
                    value45.X += ((num231 > 0) ? 144 : 36);
                    value45.X += ((num232 * num223 > 0) ? 72 : 18);
                }
                else
                {
                    value45.X += ((num231 > 0) ? 36 : 144);
                    value45.X += ((num232 * num223 > 0) ? 18 : 72);
                }
                if (flag30)
                {
                    EntitySpriteDraw(TextureAssets.WireUi[11].Value, position11, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                }
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                value45.Y = 18;
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                for (int num237 = num233 + num235; num237 != num234; num237 += num235)
                {
                    if (flag31)
                    {
                        break;
                    }
                    if (!flag32)
                    {
                        p.Y = num237;
                    }
                    else
                    {
                        p.X = num237;
                    }
                    if (WorldGen.InWorld(p.X, p.Y, 1) && tile[p.X, p.Y] != null)
                    {
                        position11 = p.ToVector2() * 16f - screenPosition;
                        value45.Y = 0;
                        if (!flag32)
                        {
                            value45.X = 90;
                        }
                        else
                        {
                            value45.X = 180;
                        }
                        if (flag30)
                        {
                            EntitySpriteDraw(TextureAssets.WireUi[11].Value, position11, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        }
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                        value45.Y = 18;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                    }
                }
                position11 = point2.ToVector2() * 16f - screenPosition;
                value45 = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
                if (!flag32)
                {
                    value45.X += ((num232 * num223 > 0) ? 18 : 72);
                }
                else
                {
                    value45.X += ((num231 > 0) ? 144 : 36);
                }
                if (flag30)
                {
                    EntitySpriteDraw(TextureAssets.WireUi[11].Value, position11, null, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                }
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color64, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                value45.Y = 18;
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, position11, value45, color63, 0f, Vector2.Zero, 1f, SpriteEffects.None);
                return;
            }
            if (proj.type == 586)
            {
                float num238 = 300f;
                if (proj.ai[0] >= 100f)
                {
                    num238 = MathHelper.Lerp(300f, 600f, (proj.ai[0] - 100f) / 200f);
                }
                if (num238 > 600f)
                {
                    num238 = 600f;
                }
                if (proj.ai[0] >= 500f)
                {
                    num238 = MathHelper.Lerp(600f, 1200f, (proj.ai[0] - 500f) / 100f);
                }
                float rotation24 = proj.rotation;
                Texture2D value46 = TextureAssets.Projectile[proj.type].Value;
                int num239 = (int)(proj.ai[0] / 6f);
                Vector2 spinningpoint3 = new Vector2(0f, 0f - num238);
                for (int num240 = 0; (float)num240 < 10f; num240++)
                {
                    Microsoft.Xna.Framework.Rectangle rectangle9 = value46.Frame(1, 5, 0, (num239 + num240) % 5);
                    float num241 = rotation24 + (float)Math.PI / 5f * (float)num240;
                    Vector2 vector50 = spinningpoint3.RotatedBy(num241) / 3f + proj.Center;
                    Microsoft.Xna.Framework.Color alpha7 = proj.GetAlpha(Lighting.GetColor(vector50.ToTileCoordinates()));
                    alpha7.A /= 2;
                    EntitySpriteDraw(value46, vector50 - screenPosition, rectangle9, alpha7, num241, rectangle9.Size() / 2f, proj.scale, SpriteEffects.None);
                }
                for (int num242 = 0; (float)num242 < 20f; num242++)
                {
                    Microsoft.Xna.Framework.Rectangle rectangle10 = value46.Frame(1, 5, 0, (num239 + num242) % 5);
                    float num243 = 0f - rotation24 + (float)Math.PI / 10f * (float)num242;
                    num243 *= 2f;
                    Vector2 vector51 = spinningpoint3.RotatedBy(num243) + proj.Center;
                    Microsoft.Xna.Framework.Color alpha7 = proj.GetAlpha(Lighting.GetColor(vector51.ToTileCoordinates()));
                    alpha7.A /= 2;
                    EntitySpriteDraw(value46, vector51 - screenPosition, rectangle10, alpha7, num243, rectangle10.Size() / 2f, proj.scale, SpriteEffects.None);
                }
                return;
            }
            if (proj.type == 536 || proj.type == 607)
            {
                Texture2D value47 = TextureAssets.Projectile[proj.type].Value;
                Vector2 position12 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                EntitySpriteDraw(scale: new Vector2(1f, proj.velocity.Length() / (float)value47.Height), texture: value47, position: position12, sourceRectangle: null, color: proj.GetAlpha(projectileColor), rotation: proj.rotation, origin: value47.Frame().Bottom(), effects: dir);
                return;
            }
            if (proj.type == 591)
            {
                Texture2D value48 = TextureAssets.Projectile[proj.type].Value;
                Vector2 position13 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Vector2 scale4 = new Vector2(1f, proj.velocity.Length() / (float)value48.Height);
                LoadNPC(139);
                Texture2D value49 = TextureAssets.Npc[139].Value;
                bool num244 = proj.velocity.X >= 0f;
                float rotation25 = proj.velocity.ToRotation() + (float)Math.PI;
                SpriteEffects effects3 = (num244 ? SpriteEffects.FlipVertically : SpriteEffects.None);
                float fromValue = 1f - proj.Opacity;
                float num245 = Utils.Remap(fromValue, 0f, 0.2f, 0f, 1f) * Utils.Remap(fromValue, 0.2f, 1f, 1f, 0f);
                EntitySpriteDraw(value49, position13, null, projectileColor * num245, rotation25, value49.Size() / 2f, 0.65f, effects3);
                Microsoft.Xna.Framework.Color color65 = new Microsoft.Xna.Framework.Color(255, 189, 163, 127) * num245;
                Microsoft.Xna.Framework.Color color66 = new Microsoft.Xna.Framework.Color(255, 21, 21, 127) * num245;
                Microsoft.Xna.Framework.Rectangle rectangle11 = value48.Frame(2);
                Vector2 origin16 = rectangle11.Bottom();
                EntitySpriteDraw(value48, position13, rectangle11, color65, proj.rotation, origin16, scale4, dir);
                rectangle11 = value48.Frame(2, 1, 1);
                EntitySpriteDraw(value48, position13, rectangle11, color66, proj.rotation, origin16, scale4, dir);
                return;
            }
            if (proj.type == 688 || proj.type == 689 || proj.type == 690)
            {
                Texture2D value50 = TextureAssets.Projectile[proj.type].Value;
                Vector2 position14 = proj.Top + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Microsoft.Xna.Framework.Rectangle rectangle12 = value50.Frame(1, projFrames[proj.type], 0, proj.frame);
                Vector2 origin17 = rectangle12.Size() * new Vector2(0.5f, 0f);
                Microsoft.Xna.Framework.Color color67 = Microsoft.Xna.Framework.Color.Lerp(proj.GetAlpha(projectileColor), Microsoft.Xna.Framework.Color.White, 0.5f);
                Microsoft.Xna.Framework.Color color68 = color67;
                color68.A = 127;
                Texture2D texture2D2 = null;
                Texture2D texture2D3 = null;
                switch (proj.type)
                {
                case 688:
                    texture2D2 = TextureAssets.GlowMask[228].Value;
                    texture2D3 = TextureAssets.Extra[86].Value;
                    break;
                case 689:
                    texture2D2 = TextureAssets.GlowMask[229].Value;
                    texture2D3 = TextureAssets.Extra[87].Value;
                    break;
                case 690:
                    texture2D2 = TextureAssets.GlowMask[230].Value;
                    texture2D3 = TextureAssets.Extra[88].Value;
                    break;
                }
                EntitySpriteDraw(value50, position14, rectangle12, color67, proj.rotation, origin17, proj.scale, dir);
                if (texture2D2 != null)
                {
                    EntitySpriteDraw(texture2D2, position14, rectangle12, color68, proj.rotation, origin17, proj.scale, dir);
                }
                if (texture2D3 != null)
                {
                    Vector2 position15 = proj.Center + Vector2.UnitY * proj.gfxOffY - screenPosition;
                    rectangle12 = texture2D3.Frame();
                    origin17 = rectangle12.Size() * new Vector2(0.5f, 1f);
                    origin17.Y -= 2f;
                    EntitySpriteDraw(texture2D3, position15, rectangle12, color67, proj.rotation, origin17, proj.scale, dir);
                }
                return;
            }
            if (proj.type == 694 || proj.type == 695 || proj.type == 696)
            {
                Texture2D value51 = TextureAssets.Projectile[proj.type].Value;
                Vector2 position16 = proj.Bottom + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Microsoft.Xna.Framework.Rectangle rectangle13 = value51.Frame(1, projFrames[proj.type], 0, proj.frame);
                Vector2 origin18 = rectangle13.Size() * new Vector2(0.5f, 1f);
                origin18.Y -= 8f;
                int type = proj.type;
                if ((uint)(type - 694) <= 1u)
                {
                    origin18.X += 3f;
                }
                Microsoft.Xna.Framework.Color color69 = Microsoft.Xna.Framework.Color.Lerp(proj.GetAlpha(projectileColor), Microsoft.Xna.Framework.Color.White, 0f);
                EntitySpriteDraw(value51, position16, rectangle13, color69, proj.rotation, origin18, proj.scale, dir);
                EntitySpriteDraw(value51, position16, rectangle13, color69 * 0.3f, proj.rotation, origin18, proj.scale * 1.1f, dir);
                return;
            }
            if (proj.type == 409)
            {
                Texture2D value52 = TextureAssets.Projectile[proj.type].Value;
                int num246 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y14 = num246 * proj.frame;
                int num247 = 10;
                int num248 = 2;
                float value53 = 0.5f;
                for (int num249 = 1; num249 < num247; num249 += num248)
                {
                    _ = ref proj.oldPos[num249];
                    Microsoft.Xna.Framework.Color newColor = projectileColor;
                    newColor = proj.GetAlpha(newColor);
                    newColor *= (float)(num247 - num249) / 15f;
                    _ = proj.oldPos[num249] - screenPosition + new Vector2(num138 + (float)num137, (float)(proj.height / 2) + proj.gfxOffY);
                    EntitySpriteDraw(value52, proj.oldPos[num249] + new Vector2(proj.width, proj.height) / 2f - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y14, value52.Width, num246), newColor, proj.rotation, new Vector2((float)value52.Width / 2f, (float)num246 / 2f), MathHelper.Lerp(proj.scale, value53, (float)num249 / 15f), dir);
                }
                EntitySpriteDraw(value52, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y14, value52.Width, num246), proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value52.Width / 2f, (float)num246 / 2f), proj.scale, dir);
                return;
            }
            if (proj.type == 437)
            {
                Texture2D value54 = TextureAssets.Projectile[proj.type].Value;
                int num250 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y15 = num250 * proj.frame;
                int num251 = 10;
                int num252 = 2;
                float value55 = 0.2f;
                for (int num253 = 1; num253 < num251; num253 += num252)
                {
                    _ = ref proj.oldPos[num253];
                    Microsoft.Xna.Framework.Color newColor2 = projectileColor;
                    newColor2 = proj.GetAlpha(newColor2);
                    newColor2 *= (float)(num251 - num253) / 15f;
                    _ = proj.oldPos[num253] - screenPosition + new Vector2(num138 + (float)num137, (float)(proj.height / 2) + proj.gfxOffY);
                    EntitySpriteDraw(value54, proj.oldPos[num253] + new Vector2(proj.width, proj.height) / 2f - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y15, value54.Width, num250), newColor2, proj.rotation, new Vector2((float)value54.Width / 2f, (float)num250 / 2f), MathHelper.Lerp(proj.scale, value55, (float)num253 / 15f), dir);
                }
                EntitySpriteDraw(value54, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y15, value54.Width, num250), Microsoft.Xna.Framework.Color.White, proj.rotation, new Vector2((float)value54.Width / 2f, (float)num250 / 2f), proj.scale + 0.2f, dir);
                EntitySpriteDraw(value54, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y15, value54.Width, num250), proj.GetAlpha(Microsoft.Xna.Framework.Color.White), proj.rotation, new Vector2((float)value54.Width / 2f, (float)num250 / 2f), proj.scale + 0.2f, dir);
                return;
            }
            if (proj.type == 384 || proj.type == 386)
            {
                Texture2D value56 = TextureAssets.Projectile[proj.type].Value;
                int num254 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y16 = num254 * proj.frame;
                EntitySpriteDraw(value56, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y16, value56.Width, num254), proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value56.Width / 2f, (float)num254 / 2f), proj.scale, dir);
                return;
            }
            if (proj.type == 439 || proj.type == 460 || proj.type == 600 || proj.type == 615 || proj.type == 630 || proj.type == 633 || proj.type == 705 || proj.type == 714)
            {
                Texture2D value57 = TextureAssets.Projectile[proj.type].Value;
                if (Main.player[proj.owner].gravDir == -1f)
                {
                    if (proj.type == 705)
                    {
                        dir |= SpriteEffects.FlipVertically;
                    }
                    if (proj.type == 615 || proj.type == 714)
                    {
                        if (Main.player[proj.owner].direction == 1)
                        {
                            dir = SpriteEffects.FlipVertically;
                        }
                        else if (Main.player[proj.owner].direction == -1)
                        {
                            dir = SpriteEffects.FlipHorizontally | SpriteEffects.FlipVertically;
                        }
                    }
                    else if (proj.type == 600 || proj.type == 439)
                    {
                        if (Main.player[proj.owner].direction == 1)
                        {
                            dir = SpriteEffects.FlipHorizontally;
                        }
                        else if (Main.player[proj.owner].direction == -1)
                        {
                            dir = SpriteEffects.None;
                        }
                    }
                }
                int num255 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y17 = num255 * proj.frame;
                Vector2 vector52 = (proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition).Floor();
                float num256 = 1f;
                if (Main.player[proj.owner].shroomiteStealth && Main.player[proj.owner].inventory[Main.player[proj.owner].selectedItem].ranged)
                {
                    float num257 = Main.player[proj.owner].stealth;
                    if ((double)num257 < 0.03)
                    {
                        num257 = 0.03f;
                    }
                    _ = (1f + num257 * 10f) / 11f;
                    projectileColor *= num257;
                    num256 = num257;
                }
                if (Main.player[proj.owner].setVortex && Main.player[proj.owner].inventory[Main.player[proj.owner].selectedItem].ranged)
                {
                    float num258 = Main.player[proj.owner].stealth;
                    if ((double)num258 < 0.03)
                    {
                        num258 = 0.03f;
                    }
                    _ = (1f + num258 * 10f) / 11f;
                    projectileColor = projectileColor.MultiplyRGBA(new Microsoft.Xna.Framework.Color(Vector4.Lerp(Vector4.One, new Vector4(0f, 0.12f, 0.16f, 0f), 1f - num258)));
                    num256 = num258;
                }
                if (proj.type == 714)
                {
                    y17 = 0;
                    instance.LoadItem(3930);
                    value57 = TextureAssets.Item[3930].Value;
                }
                EntitySpriteDraw(value57, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                if (proj.type == 439)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[35].Value, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * num256, proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                }
                else if (proj.type == 714)
                {
                    y17 = num255 * proj.frame;
                    Microsoft.Xna.Framework.Color color70 = hslToRgb(proj.ai[0] / 90f % 1f, 1f, 0.5f);
                    color70.A = 120;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), color70 * num256, proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                }
                else if (proj.type == 615)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[192].Value, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * num256, proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                }
                else if (proj.type == 630)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[200].Value, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * num256, proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                    if (proj.localAI[0] > 0f)
                    {
                        int frameY = 6 - (int)(proj.localAI[0] / 1f);
                        value57 = TextureAssets.Extra[65].Value;
                        EntitySpriteDraw(value57, vector52 + Vector2.Normalize(proj.velocity) * 2f, value57.Frame(1, 6, 0, frameY), new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * num256, proj.rotation, new Vector2(dir.HasFlag(SpriteEffects.FlipHorizontally) ? value57.Width : 0, (float)num255 / 2f - 2f), proj.scale, dir);
                    }
                }
                else if (proj.type == 600)
                {
                    Microsoft.Xna.Framework.Color portalColor = PortalHelper.GetPortalColor(proj.owner, (int)proj.ai[1]);
                    portalColor.A = 70;
                    EntitySpriteDraw(TextureAssets.GlowMask[173].Value, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), portalColor, proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                }
                else if (proj.type == 460)
                {
                    if (Math.Abs(proj.rotation - (float)Math.PI / 2f) > (float)Math.PI / 2f)
                    {
                        dir |= SpriteEffects.FlipVertically;
                    }
                    EntitySpriteDraw(TextureAssets.GlowMask[102].Value, vector52, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), new Microsoft.Xna.Framework.Color(255, 255, 255, 0), proj.rotation - (float)Math.PI / 2f, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                    if (proj.ai[0] > 180f && Main.projectile[(int)proj.ai[1]].type == 461)
                    {
                        DrawProj((int)proj.ai[1]);
                    }
                }
                else if (proj.type == 633)
                {
                    float num259 = (float)Math.Cos((float)Math.PI * 2f * (proj.ai[0] / 30f)) * 2f + 2f;
                    if (proj.ai[0] > 120f)
                    {
                        num259 = 4f;
                    }
                    for (float num260 = 0f; num260 < 4f; num260 += 1f)
                    {
                        EntitySpriteDraw(value57, vector52 + Vector2.UnitY.RotatedBy(num260 * ((float)Math.PI * 2f) / 4f) * num259, new Microsoft.Xna.Framework.Rectangle(0, y17, value57.Width, num255), proj.GetAlpha(projectileColor).MultiplyRGBA(new Microsoft.Xna.Framework.Color(255, 255, 255, 0)) * 0.03f, proj.rotation, new Vector2((float)value57.Width / 2f, (float)num255 / 2f), proj.scale, dir);
                    }
                }
                return;
            }
            if (proj.type == 442)
            {
                Texture2D value58 = TextureAssets.Projectile[proj.type].Value;
                int num261 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y18 = num261 * proj.frame;
                Vector2 position17 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                EntitySpriteDraw(value58, position17, new Microsoft.Xna.Framework.Rectangle(0, y18, value58.Width, num261), proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value58.Width / 2f, (float)num261 / 2f), proj.scale, dir);
                EntitySpriteDraw(TextureAssets.GlowMask[37].Value, position17, new Microsoft.Xna.Framework.Rectangle(0, y18, value58.Width, num261), new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * (1f - (float)proj.alpha / 255f), proj.rotation, new Vector2((float)value58.Width / 2f, (float)num261 / 2f), proj.scale, dir);
                return;
            }
            if (proj.type == 447)
            {
                Texture2D value59 = TextureAssets.Projectile[proj.type].Value;
                Texture2D value60 = TextureAssets.Extra[4].Value;
                int num262 = value59.Height / projFrames[proj.type];
                int y19 = num262 * proj.frame;
                int num263 = value60.Height / projFrames[proj.type];
                int num264 = num263 * proj.frame;
                Microsoft.Xna.Framework.Rectangle value61 = new Microsoft.Xna.Framework.Rectangle(0, num264, value60.Width, num263);
                Vector2 vector53 = proj.position + new Vector2(proj.width, 0f) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                EntitySpriteDraw(TextureAssets.Extra[4].Value, vector53, value61, proj.GetAlpha(projectileColor), proj.rotation, new Vector2(value60.Width / 2, 0f), proj.scale, dir);
                int num265 = proj.height - num262 - 14;
                if (num265 < 0)
                {
                    num265 = 0;
                }
                if (num265 > 0)
                {
                    if (num264 == num263 * 3)
                    {
                        num264 = num263 * 2;
                    }
                    EntitySpriteDraw(TextureAssets.Extra[4].Value, vector53 + Vector2.UnitY * (num263 - 1), new Microsoft.Xna.Framework.Rectangle(0, num264 + num263 - 1, value60.Width, 1), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(value60.Width / 2, 0f), new Vector2(1f, num265), dir);
                }
                value61.Width = value59.Width;
                value61.Y = y19;
                EntitySpriteDraw(value59, vector53 + Vector2.UnitY * (num263 - 1 + num265), value61, proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value59.Width / 2f, 0f), proj.scale, dir);
                return;
            }
            if (proj.type == 455)
            {
                if (proj.velocity == Vector2.Zero)
                {
                    return;
                }
                Texture2D value62 = TextureAssets.Projectile[proj.type].Value;
                Texture2D value63 = TextureAssets.Extra[21].Value;
                Texture2D value64 = TextureAssets.Extra[22].Value;
                float num266 = proj.localAI[1];
                Microsoft.Xna.Framework.Color color71 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.9f;
                EntitySpriteDraw(value62, proj.Center - screenPosition, null, color71, proj.rotation, value62.Size() / 2f, proj.scale, SpriteEffects.None);
                num266 -= (float)(value62.Height / 2 + value64.Height) * proj.scale;
                Vector2 center3 = proj.Center;
                center3 += proj.velocity * proj.scale * value62.Height / 2f;
                if (num266 > 0f)
                {
                    float num267 = 0f;
                    Microsoft.Xna.Framework.Rectangle value65 = new Microsoft.Xna.Framework.Rectangle(0, 16 * (proj.timeLeft / 3 % 5), value63.Width, 16);
                    while (num267 + 1f < num266)
                    {
                        if (num266 - num267 < (float)value65.Height)
                        {
                            value65.Height = (int)(num266 - num267);
                        }
                        EntitySpriteDraw(value63, center3 - screenPosition, value65, color71, proj.rotation, new Vector2(value65.Width / 2, 0f), proj.scale, SpriteEffects.None);
                        num267 += (float)value65.Height * proj.scale;
                        center3 += proj.velocity * value65.Height * proj.scale;
                        value65.Y += 16;
                        if (value65.Y + value65.Height > value63.Height)
                        {
                            value65.Y = 0;
                        }
                    }
                }
                EntitySpriteDraw(value64, center3 - screenPosition, null, color71, proj.rotation, value64.Frame().Top(), proj.scale, SpriteEffects.None);
                return;
            }
            if (proj.type == 461)
            {
                if (proj.velocity == Vector2.Zero)
                {
                    return;
                }
                Texture2D value66 = TextureAssets.Projectile[proj.type].Value;
                float num268 = proj.localAI[1];
                Microsoft.Xna.Framework.Color color72 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.9f;
                Microsoft.Xna.Framework.Rectangle rectangle14 = new Microsoft.Xna.Framework.Rectangle(0, 0, value66.Width, 22);
                Vector2 vector54 = new Vector2(0f, Main.player[proj.owner].gfxOffY);
                EntitySpriteDraw(value66, proj.Center.Floor() - screenPosition + vector54, rectangle14, color72, proj.rotation, rectangle14.Size() / 2f, proj.scale, SpriteEffects.None);
                num268 -= 33f * proj.scale;
                Vector2 vector55 = proj.Center.Floor();
                vector55 += proj.velocity * proj.scale * 10.5f;
                rectangle14 = new Microsoft.Xna.Framework.Rectangle(0, 25, value66.Width, 28);
                if (num268 > 0f)
                {
                    float num269 = 0f;
                    while (num269 + 1f < num268)
                    {
                        if (num268 - num269 < (float)rectangle14.Height)
                        {
                            rectangle14.Height = (int)(num268 - num269);
                        }
                        EntitySpriteDraw(value66, vector55 - screenPosition + vector54, rectangle14, color72, proj.rotation, new Vector2(rectangle14.Width / 2, 0f), proj.scale, SpriteEffects.None);
                        num269 += (float)rectangle14.Height * proj.scale;
                        vector55 += proj.velocity * rectangle14.Height * proj.scale;
                    }
                }
                EntitySpriteDraw(sourceRectangle: new Microsoft.Xna.Framework.Rectangle(0, 56, value66.Width, 22), texture: value66, position: vector55 - screenPosition + vector54, color: color72, rotation: proj.rotation, origin: value66.Frame().Top(), scale: proj.scale, effects: SpriteEffects.None);
                return;
            }
            if (proj.type == 632)
            {
                if (!(proj.velocity == Vector2.Zero))
                {
                    Texture2D value67 = TextureAssets.Projectile[proj.type].Value;
                    float num270 = proj.localAI[1];
                    float laserLuminance = 0.5f;
                    float laserAlphaMultiplier = 0f;
                    Microsoft.Xna.Framework.Color color73 = hslToRgb(proj.GetLastPrismHue(proj.ai[0], ref laserLuminance, ref laserAlphaMultiplier), 1f, laserLuminance);
                    color73.A = (byte)((float)(int)color73.A * laserAlphaMultiplier);
                    Vector2 vector56 = proj.Center.Floor();
                    vector56 += proj.velocity * proj.scale * 10.5f;
                    num270 -= proj.scale * 14.5f * proj.scale;
                    Vector2 vector57 = new Vector2(proj.scale);
                    DelegateMethods.f_1 = 1f;
                    DelegateMethods.c_1 = color73 * 0.75f * proj.Opacity;
                    _ = proj.oldPos[0] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                    Utils.DrawLaser(spriteBatch, value67, vector56 - screenPosition, vector56 + proj.velocity * num270 - screenPosition, vector57, DelegateMethods.RainbowLaserDraw);
                    DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * 0.75f * proj.Opacity;
                    Utils.DrawLaser(spriteBatch, value67, vector56 - screenPosition, vector56 + proj.velocity * num270 - screenPosition, vector57 / 2f, DelegateMethods.RainbowLaserDraw);
                }
                return;
            }
            if (proj.type == 642)
            {
                if (!(proj.velocity == Vector2.Zero))
                {
                    Texture2D value68 = TextureAssets.Projectile[proj.type].Value;
                    float num271 = proj.localAI[1];
                    Microsoft.Xna.Framework.Color c_ = new Microsoft.Xna.Framework.Color(255, 255, 255, 127);
                    Vector2 vector58 = proj.Center.Floor();
                    num271 -= proj.scale * 10.5f;
                    Vector2 vector59 = new Vector2(proj.scale);
                    DelegateMethods.f_1 = 1f;
                    DelegateMethods.c_1 = c_;
                    DelegateMethods.i_1 = 54000 - (int)time / 2;
                    _ = proj.oldPos[0] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                    Utils.DrawLaser(spriteBatch, value68, vector58 - screenPosition, vector58 + proj.velocity * num271 - screenPosition, vector59, DelegateMethods.TurretLaserDraw);
                    DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * 0.75f * proj.Opacity;
                    Utils.DrawLaser(spriteBatch, value68, vector58 - screenPosition, vector58 + proj.velocity * num271 - screenPosition, vector59 / 2f, DelegateMethods.TurretLaserDraw);
                }
                return;
            }
            if (proj.type == 611)
            {
                _ = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Texture2D value69 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Color alpha8 = proj.GetAlpha(projectileColor);
                if (proj.velocity == Vector2.Zero)
                {
                    return;
                }
                float num272 = proj.velocity.Length() + 16f;
                bool flag33 = num272 < 100f;
                Vector2 vector60 = Vector2.Normalize(proj.velocity);
                Microsoft.Xna.Framework.Rectangle rectangle15 = new Microsoft.Xna.Framework.Rectangle(0, 2, value69.Width, 40);
                Vector2 vector61 = new Vector2(0f, Main.player[proj.owner].gfxOffY);
                float rotation26 = proj.rotation + (float)Math.PI;
                EntitySpriteDraw(value69, proj.Center.Floor() - screenPosition + vector61, rectangle15, alpha8, rotation26, rectangle15.Size() / 2f - Vector2.UnitY * 4f, proj.scale, SpriteEffects.None);
                num272 -= 40f * proj.scale;
                Vector2 vector62 = proj.Center.Floor();
                vector62 += vector60 * proj.scale * 24f;
                rectangle15 = new Microsoft.Xna.Framework.Rectangle(0, 68, value69.Width, 18);
                if (num272 > 0f)
                {
                    float num273 = 0f;
                    while (num273 + 1f < num272)
                    {
                        if (num272 - num273 < (float)rectangle15.Height)
                        {
                            rectangle15.Height = (int)(num272 - num273);
                        }
                        EntitySpriteDraw(value69, vector62 - screenPosition + vector61, rectangle15, alpha8, rotation26, new Vector2(rectangle15.Width / 2, 0f), proj.scale, SpriteEffects.None);
                        num273 += (float)rectangle15.Height * proj.scale;
                        vector62 += vector60 * rectangle15.Height * proj.scale;
                    }
                }
                Vector2 vector63 = vector62;
                vector62 = proj.Center.Floor();
                vector62 += vector60 * proj.scale * 24f;
                rectangle15 = new Microsoft.Xna.Framework.Rectangle(0, 46, value69.Width, 18);
                int num274 = 18;
                if (flag33)
                {
                    num274 = 9;
                }
                float num275 = num272;
                if (num272 > 0f)
                {
                    float num276 = 0f;
                    float num277 = num275 / (float)num274;
                    num276 += num277 * 0.25f;
                    vector62 += vector60 * num277 * 0.25f;
                    for (int num278 = 0; num278 < num274; num278++)
                    {
                        float num279 = num277;
                        if (num278 == 0)
                        {
                            num279 *= 0.75f;
                        }
                        EntitySpriteDraw(value69, vector62 - screenPosition + vector61, rectangle15, alpha8, rotation26, new Vector2(rectangle15.Width / 2, 0f), proj.scale, SpriteEffects.None);
                        num276 += num279;
                        vector62 += vector60 * num279;
                    }
                }
                EntitySpriteDraw(sourceRectangle: new Microsoft.Xna.Framework.Rectangle(0, 90, value69.Width, 48), texture: value69, position: vector63 - screenPosition + vector61, color: alpha8, rotation: rotation26, origin: value69.Frame().Top(), scale: proj.scale, effects: SpriteEffects.None);
                return;
            }
            if (proj.type == 537)
            {
                if (proj.velocity == Vector2.Zero)
                {
                    return;
                }
                Texture2D value70 = TextureAssets.Projectile[proj.type].Value;
                float num280 = proj.localAI[1];
                float fromValue2 = Utils.Remap(proj.localAI[0], 20f, 30f, 0f, 1f) * Utils.Remap(proj.localAI[0], 60f, 90f, 1f, 0f);
                float toMax = 1.5f;
                float num281 = Utils.Remap(fromValue2, 0f, 1f, 0.25f, toMax);
                Microsoft.Xna.Framework.Color color74 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.9f;
                Microsoft.Xna.Framework.Rectangle rectangle16 = new Microsoft.Xna.Framework.Rectangle(0, 0, value70.Width, 22);
                Vector2 vector64 = new Vector2(0f, npc[(int)proj.ai[1]].gfxOffY);
                EntitySpriteDraw(value70, proj.Center.Floor() - screenPosition + vector64, rectangle16, color74, proj.rotation, rectangle16.Size() / 2f, num281, SpriteEffects.None);
                num280 -= 33f * proj.scale;
                Vector2 vector65 = proj.Center.Floor();
                vector65 += proj.velocity * num281 * 10.5f;
                rectangle16 = new Microsoft.Xna.Framework.Rectangle(0, 25, value70.Width, 28);
                if (num280 > 0f)
                {
                    float num282 = 0f;
                    while (num282 + 1f < num280)
                    {
                        if (num280 - num282 < (float)rectangle16.Height)
                        {
                            rectangle16.Height = (int)(num280 - num282);
                        }
                        EntitySpriteDraw(value70, vector65 - screenPosition + vector64, rectangle16, color74, proj.rotation, new Vector2(rectangle16.Width / 2, 0f), num281, SpriteEffects.None);
                        num282 += (float)rectangle16.Height * num281;
                        vector65 += proj.velocity * rectangle16.Height * num281;
                    }
                }
                EntitySpriteDraw(sourceRectangle: new Microsoft.Xna.Framework.Rectangle(0, 56, value70.Width, 22), texture: value70, position: vector65 - screenPosition + vector64, color: color74, rotation: proj.rotation, origin: value70.Frame().Top(), scale: num281, effects: SpriteEffects.None);
                return;
            }
            if (proj.type == 456)
            {
                Texture2D value71 = TextureAssets.Projectile[proj.type].Value;
                Texture2D value72 = TextureAssets.Extra[23].Value;
                Texture2D value73 = TextureAssets.Extra[24].Value;
                Vector2 vector66 = new Vector2(0f, 216f);
                Vector2 value74 = npc[(int)Math.Abs(proj.ai[0]) - 1].Center - proj.Center + vector66;
                float num283 = value74.Length();
                Vector2 vector67 = Vector2.Normalize(value74);
                Microsoft.Xna.Framework.Rectangle rectangle17 = value71.Frame();
                rectangle17.Height /= 4;
                rectangle17.Y += proj.frame * rectangle17.Height;
                EntitySpriteDraw(color: proj.GetAlpha(Microsoft.Xna.Framework.Color.Lerp(projectileColor, Microsoft.Xna.Framework.Color.White, 0.3f)), texture: value71, position: proj.Center - screenPosition, sourceRectangle: rectangle17, rotation: proj.rotation, origin: rectangle17.Size() / 2f, scale: proj.scale, effects: SpriteEffects.None);
                num283 -= (float)(rectangle17.Height / 2 + value73.Height) * proj.scale;
                Vector2 center4 = proj.Center;
                center4 += vector67 * proj.scale * rectangle17.Height / 2f;
                if (num283 > 0f)
                {
                    float num284 = 0f;
                    Microsoft.Xna.Framework.Rectangle rectangle18 = new Microsoft.Xna.Framework.Rectangle(0, 0, value72.Width, value72.Height);
                    while (num284 + 1f < num283)
                    {
                        if (num283 - num284 < (float)rectangle18.Height)
                        {
                            rectangle18.Height = (int)(num283 - num284);
                        }
                        Microsoft.Xna.Framework.Point point3 = center4.ToTileCoordinates();
                        Microsoft.Xna.Framework.Color color75 = Lighting.GetColor(point3.X, point3.Y);
                        color75 = Microsoft.Xna.Framework.Color.Lerp(color75, Microsoft.Xna.Framework.Color.White, 0.3f);
                        EntitySpriteDraw(value72, center4 - screenPosition, rectangle18, proj.GetAlpha(color75), proj.rotation, rectangle18.Bottom(), proj.scale, SpriteEffects.None);
                        num284 += (float)rectangle18.Height * proj.scale;
                        center4 += vector67 * rectangle18.Height * proj.scale;
                    }
                }
                Microsoft.Xna.Framework.Point point4 = center4.ToTileCoordinates();
                Microsoft.Xna.Framework.Color color76 = Lighting.GetColor(point4.X, point4.Y);
                color76 = Microsoft.Xna.Framework.Color.Lerp(color76, Microsoft.Xna.Framework.Color.White, 0.3f);
                Microsoft.Xna.Framework.Rectangle value75 = value73.Frame();
                if (num283 < 0f)
                {
                    value75.Height += (int)num283;
                }
                EntitySpriteDraw(value73, center4 - screenPosition, value75, color76, proj.rotation, new Vector2((float)value75.Width / 2f, value75.Height), proj.scale, SpriteEffects.None);
                return;
            }
            if (proj.type == 443)
            {
                Texture2D value76 = TextureAssets.Projectile[proj.type].Value;
                float num285 = 30f;
                float num286 = num285 * 4f;
                float num287 = (float)Math.PI * 2f * proj.ai[0] / num285;
                float num288 = (float)Math.PI * 2f * proj.ai[0] / num286;
                Vector2 vector68 = -Vector2.UnitY.RotatedBy(num287);
                float scale5 = 0.75f + vector68.Y * 0.25f;
                float scale6 = 0.8f - vector68.Y * 0.2f;
                int num289 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y20 = num289 * proj.frame;
                Vector2 position18 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                EntitySpriteDraw(value76, position18, new Microsoft.Xna.Framework.Rectangle(0, y20, value76.Width, num289), proj.GetAlpha(projectileColor), proj.rotation + num288, new Vector2((float)value76.Width / 2f, (float)num289 / 2f), scale5, dir);
                EntitySpriteDraw(value76, position18, new Microsoft.Xna.Framework.Rectangle(0, y20, value76.Width, num289), proj.GetAlpha(projectileColor), proj.rotation + ((float)Math.PI * 2f - num288), new Vector2((float)value76.Width / 2f, (float)num289 / 2f), scale6, dir);
                return;
            }
            if (proj.type == 656 || proj.type == 657)
            {
                float num290 = 900f;
                if (proj.type == 657)
                {
                    num290 = 300f;
                }
                float num291 = 15f;
                float num292 = 15f;
                float num293 = proj.ai[0];
                float num294 = MathHelper.Clamp(num293 / 30f, 0f, 1f);
                if (num293 > num290 - 60f)
                {
                    num294 = MathHelper.Lerp(1f, 0f, (num293 - (num290 - 60f)) / 60f);
                }
                Microsoft.Xna.Framework.Point point5 = proj.Center.ToTileCoordinates();
                Collision.ExpandVertically(point5.X, point5.Y, out var topY, out var bottomY, (int)num291, (int)num292);
                topY++;
                bottomY--;
                float num295 = 0.2f;
                Vector2 value77 = new Vector2(point5.X, topY) * 16f + new Vector2(8f);
                Vector2 value78 = new Vector2(point5.X, bottomY) * 16f + new Vector2(8f);
                Vector2.Lerp(value77, value78, 0.5f);
                Vector2 vector69 = new Vector2(0f, value78.Y - value77.Y);
                vector69.X = vector69.Y * num295;
                new Vector2(value77.X - vector69.X / 2f, value77.Y);
                Texture2D value79 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle rectangle19 = value79.Frame();
                Vector2 origin19 = rectangle19.Size() / 2f;
                float num296 = -(float)Math.PI / 50f * num293;
                Vector2 spinningpoint4 = Vector2.UnitY.RotatedBy(num293 * 0.1f);
                float num297 = 0f;
                float num298 = 5.1f;
                Microsoft.Xna.Framework.Color value80 = new Microsoft.Xna.Framework.Color(212, 192, 100);
                for (float num299 = (int)value78.Y; num299 > (float)(int)value77.Y; num299 -= num298)
                {
                    num297 += num298;
                    float num300 = num297 / vector69.Y;
                    float num301 = num297 * ((float)Math.PI * 2f) / -20f;
                    float num302 = num300 - 0.15f;
                    Vector2 position19 = spinningpoint4.RotatedBy(num301);
                    Vector2 vector70 = new Vector2(0f, num300 + 1f);
                    vector70.X = vector70.Y * num295;
                    Microsoft.Xna.Framework.Color color77 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, value80, num300 * 2f);
                    if (num300 > 0.5f)
                    {
                        color77 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, value80, 2f - num300 * 2f);
                    }
                    color77.A = (byte)((float)(int)color77.A * 0.5f);
                    color77 *= num294;
                    position19 *= vector70 * 100f;
                    position19.Y = 0f;
                    position19.X = 0f;
                    position19 += new Vector2(value78.X, num299) - screenPosition;
                    EntitySpriteDraw(value79, position19, rectangle19, color77, num296 + num301, origin19, 1f + num302, SpriteEffects.None);
                }
                return;
            }
            if (proj.type == 704)
            {
                float num303 = 300f;
                float num304 = proj.ai[0];
                float num305 = MathHelper.Clamp(num304 / 30f, 0f, 1f);
                if (num304 > num303 - 60f)
                {
                    num305 = MathHelper.Lerp(1f, 0f, (num304 - (num303 - 60f)) / 60f);
                }
                float num306 = 0.2f;
                Vector2 top2 = proj.Top;
                Vector2 bottom = proj.Bottom;
                Vector2.Lerp(top2, bottom, 0.5f);
                Vector2 vector71 = new Vector2(0f, bottom.Y - top2.Y);
                vector71.X = vector71.Y * num306;
                new Vector2(top2.X - vector71.X / 2f, top2.Y);
                Texture2D value81 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle rectangle20 = value81.Frame();
                Vector2 origin20 = rectangle20.Size() / 2f;
                float num307 = -(float)Math.PI / 20f * num304 * (float)((!(proj.velocity.X > 0f)) ? 1 : (-1));
                SpriteEffects effects4 = ((proj.velocity.X > 0f) ? SpriteEffects.FlipVertically : SpriteEffects.None);
                bool flag34 = proj.velocity.X > 0f;
                Vector2 spinningpoint5 = Vector2.UnitY.RotatedBy(num304 * 0.14f);
                float num308 = 0f;
                float num309 = 5.01f + num304 / 150f * -0.9f;
                if (num309 < 4.11f)
                {
                    num309 = 4.11f;
                }
                Microsoft.Xna.Framework.Color value82 = new Microsoft.Xna.Framework.Color(160, 140, 100, 127);
                Microsoft.Xna.Framework.Color color78 = new Microsoft.Xna.Framework.Color(140, 160, 255, 127);
                float num310 = num304 % 60f;
                if (num310 < 30f)
                {
                    color78 *= Utils.GetLerpValue(22f, 30f, num310, clamped: true);
                }
                else
                {
                    color78 *= Utils.GetLerpValue(38f, 30f, num310, clamped: true);
                }
                bool flag35 = color78 != Microsoft.Xna.Framework.Color.Transparent;
                for (float num311 = (int)bottom.Y; num311 > (float)(int)top2.Y; num311 -= num309)
                {
                    num308 += num309;
                    float num312 = num308 / vector71.Y;
                    float num313 = num308 * ((float)Math.PI * 2f) / -20f;
                    if (flag34)
                    {
                        num313 *= -1f;
                    }
                    float num314 = num312 - 0.35f;
                    Vector2 position20 = spinningpoint5.RotatedBy(num313);
                    Vector2 vector72 = new Vector2(0f, num312 + 1f);
                    vector72.X = vector72.Y * num306;
                    Microsoft.Xna.Framework.Color color79 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, value82, num312 * 2f);
                    if (num312 > 0.5f)
                    {
                        color79 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, value82, 2f - num312 * 2f);
                    }
                    color79.A = (byte)((float)(int)color79.A * 0.5f);
                    color79 *= num305;
                    position20 *= vector72 * 100f;
                    position20.Y = 0f;
                    position20.X = 0f;
                    position20 += new Vector2(bottom.X, num311) - screenPosition;
                    if (flag35)
                    {
                        Microsoft.Xna.Framework.Color color80 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color78, num312 * 2f);
                        if (num312 > 0.5f)
                        {
                            color80 = Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color78, 2f - num312 * 2f);
                        }
                        color80.A = (byte)((float)(int)color80.A * 0.5f);
                        color80 *= num305;
                        EntitySpriteDraw(value81, position20, rectangle20, color80, num307 + num313, origin20, (1f + num314) * 0.8f, effects4);
                    }
                    EntitySpriteDraw(value81, position20, rectangle20, color79, num307 + num313, origin20, 1f + num314, effects4);
                }
                return;
            }
            if (proj.type == 444 || proj.type == 446 || proj.type == 490 || proj.type == 464 || proj.type == 502 || proj.type == 538 || proj.type == 540 || proj.type == 579 || proj.type == 578 || proj.type == 813 || proj.type == 583 || proj.type == 584 || proj.type == 616 || proj.type == 617 || proj.type == 618 || proj.type == 641 || (proj.type >= 646 && proj.type <= 649) || proj.type == 653 || proj.type == 186 || proj.type == 662 || proj.type == 685 || proj.type == 673 || proj.type == 676 || proj.type == 697 || proj.type == 699 || proj.type == 707 || proj.type == 708 || proj.type == 719 || proj.type == 761 || proj.type == 762 || proj.type == 763 || proj.type == 772 || proj.type == 802 || proj.type == 842 || proj.type == 865 || proj.type == 921 || proj.type == 926 || proj.type == 757 || proj.type == 25 || proj.type == 35 || proj.type == 63 || proj.type == 154 || proj.type == 247 || proj.type == 26 || proj.type == 928 || proj.type == 16 || proj.type == 34 || proj.type == 79 || proj.type == 936 || proj.type == 937 || proj.type == 938 || proj.type == 939 || proj.type == 940 || proj.type == 941 || proj.type == 942 || proj.type == 943 || proj.type == 944 || proj.type == 945 || proj.type == 971 || proj.type == 975 || proj.type == 1000 || proj.type == 1012 || proj.type == 1018 || proj.type == 1020 || (((proj.type >= 776 && proj.type <= 801) || (proj.type >= 803 && proj.type <= 810)) && proj.type != 779 && proj.type != 783 && proj.type != 862 && proj.type != 863))
            {
                Vector2 vector73 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Texture2D value83 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Color color81 = proj.GetAlpha(projectileColor);
                Vector2 origin21 = new Vector2(value83.Width, value83.Height) / 2f;
                float num315 = proj.rotation;
                Vector2 vector74 = Vector2.One * proj.scale;
                Microsoft.Xna.Framework.Rectangle? sourceRectangle5 = null;
                if (proj.type == 446)
                {
                    origin21.Y = 4f;
                }
                if (proj.type == 1020)
                {
                    origin21.Y = 14f;
                }
                if (proj.type == 865)
                {
                    vector73 += new Vector2(1f, -1f);
                    dir = ((proj.DirectionFrom(Main.player[proj.owner].Center).SafeNormalize(Vector2.Zero).X > 0f) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
                }
                if (proj.type == 16)
                {
                    float lerpValue7 = Utils.GetLerpValue(0f, 8f, proj.velocity.Length(), clamped: true);
                    num315 *= lerpValue7;
                    vector74 *= 0.6f;
                    vector74.Y *= MathHelper.Lerp(1f, 0.8f, lerpValue7);
                    vector74.X *= MathHelper.Lerp(1f, 1.5f, lerpValue7);
                }
                if (proj.type == 34)
                {
                    float lerpValue8 = Utils.GetLerpValue(0f, 8f, proj.velocity.Length(), clamped: true);
                    num315 *= lerpValue8;
                    vector74.X *= MathHelper.Lerp(1f, 0.8f, lerpValue8);
                    num315 += -(float)Math.PI / 2f * lerpValue8;
                    sourceRectangle5 = value83.Frame(1, projFrames[proj.type], 0, proj.frame);
                    origin21 = sourceRectangle5.Value.Size() / 2f;
                    vector73 -= proj.velocity * 1f;
                    vector73 = proj.oldPos[0] + proj.Size / 2f - screenPosition - proj.velocity / 2f;
                }
                if (proj.type == 79)
                {
                    num315 = 0f;
                    vector74 *= Utils.GetLerpValue(32f, 0f, proj.position.Distance(proj.oldPos[12]), clamped: true);
                    color81 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0);
                }
                if (proj.type == 761 || proj.type == 762)
                {
                    dir = ((proj.spriteDirection <= 0) ? SpriteEffects.FlipVertically : SpriteEffects.None);
                }
                if (proj.type == 662 || proj.type == 685)
                {
                    origin21 = new Vector2(6f, 6f);
                }
                if (proj.type == 699 || proj.type == 708)
                {
                    Player player4 = Main.player[proj.owner];
                    origin21 = new Vector2((proj.spriteDirection == 1) ? ((float)value83.Width - -8f) : (-8f), (player4.gravDir == 1f) ? (-8f) : ((float)value83.Height - -8f));
                    if (player4.gravDir == -1f)
                    {
                        dir |= SpriteEffects.FlipVertically;
                        num315 += (float)Math.PI / 2f * (float)(-proj.spriteDirection);
                    }
                }
                if (proj.type == 938 || proj.type == 939 || proj.type == 940 || proj.type == 941 || proj.type == 942 || proj.type == 943 || proj.type == 944 || proj.type == 945)
                {
                    num315 -= (float)Math.PI / 4f * (float)proj.spriteDirection;
                }
                if (proj.type == 502)
                {
                    LoadProjectile(250);
                    Texture2D value84 = TextureAssets.Projectile[250].Value;
                    Vector2 origin22 = new Vector2(value84.Width / 2, 0f);
                    Vector2 vector75 = new Vector2(proj.width, proj.height) / 2f;
                    Microsoft.Xna.Framework.Color white3 = Microsoft.Xna.Framework.Color.White;
                    white3.A = 127;
                    for (int num316 = proj.oldPos.Length - 1; num316 > 0; num316--)
                    {
                        Vector2 vector76 = proj.oldPos[num316] + vector75;
                        if (!(vector76 == vector75))
                        {
                            Vector2 vector77 = proj.oldPos[num316 - 1] + vector75;
                            float rotation27 = (vector77 - vector76).ToRotation() - (float)Math.PI / 2f;
                            Vector2 scale7 = new Vector2(1f, Vector2.Distance(vector76, vector77) / (float)value84.Height);
                            Microsoft.Xna.Framework.Color color82 = white3 * (1f - (float)num316 / (float)proj.oldPos.Length);
                            EntitySpriteDraw(value84, vector76 - screenPosition, null, color82, rotation27, origin22, scale7, dir);
                        }
                    }
                }
                else if (proj.type == 540 && proj.velocity != Vector2.Zero)
                {
                    float num317 = 0f;
                    if (proj.ai[0] >= 10f)
                    {
                        num317 = (proj.ai[0] - 10f) / 10f;
                    }
                    if (proj.ai[0] >= 20f)
                    {
                        num317 = (20f - proj.ai[0]) / 10f;
                    }
                    if (num317 > 1f)
                    {
                        num317 = 1f;
                    }
                    if (num317 < 0f)
                    {
                        num317 = 0f;
                    }
                    if (num317 != 0f)
                    {
                        Texture2D value85 = TextureAssets.Extra[47].Value;
                        Vector2 origin23 = new Vector2(value85.Width / 2, 0f);
                        Microsoft.Xna.Framework.Color color83 = color81 * num317 * 0.7f;
                        Vector2 position21 = proj.Center - screenPosition;
                        Vector2 vector78 = proj.velocity.ToRotation().ToRotationVector2() * value83.Width / 3f;
                        vector78 = Vector2.Zero;
                        position21 += vector78;
                        float rotation28 = proj.velocity.ToRotation() - (float)Math.PI / 2f;
                        Vector2 scale8 = new Vector2(1f, (proj.velocity.Length() - vector78.Length() * 2f) / (float)value85.Height);
                        EntitySpriteDraw(value85, position21, null, color83, rotation28, origin23, scale8, SpriteEffects.None);
                    }
                }
                if (proj.type == 578 || proj.type == 579 || proj.type == 641 || proj.type == 813)
                {
                    Microsoft.Xna.Framework.Color color84 = color81 * 0.8f;
                    color84.A /= 2;
                    Microsoft.Xna.Framework.Color color85 = Microsoft.Xna.Framework.Color.Lerp(color81, Microsoft.Xna.Framework.Color.Black, 0.5f);
                    color85.A = color81.A;
                    float num318 = 0.95f + (proj.rotation * 0.75f).ToRotationVector2().Y * 0.1f;
                    color85 *= num318;
                    float scale9 = 0.6f + proj.scale * 0.6f * num318;
                    Texture2D value86 = TextureAssets.Extra[50].Value;
                    bool flag36 = true;
                    if (proj.type == 813)
                    {
                        flag36 = false;
                        value86 = TextureAssets.Extra[131].Value;
                    }
                    Vector2 origin24 = value86.Size() / 2f;
                    EntitySpriteDraw(value86, vector73, null, color85, 0f - num315 + 0.35f, origin24, scale9, dir ^ SpriteEffects.FlipHorizontally);
                    EntitySpriteDraw(value86, vector73, null, color81, 0f - num315, origin24, proj.scale, dir ^ SpriteEffects.FlipHorizontally);
                    if (flag36)
                    {
                        EntitySpriteDraw(value83, vector73, null, color84, (0f - num315) * 0.7f, origin21, proj.scale, dir ^ SpriteEffects.FlipHorizontally);
                    }
                    EntitySpriteDraw(value86, vector73, null, color81 * 0.8f, num315 * 0.5f, origin24, proj.scale * 0.9f, dir);
                    color81.A = 0;
                    if (proj.type == 813)
                    {
                        num315 = 0f;
                    }
                }
                if (proj.type == 617)
                {
                    Microsoft.Xna.Framework.Color color86 = color81 * 0.8f;
                    color86.A /= 2;
                    Microsoft.Xna.Framework.Color color87 = Microsoft.Xna.Framework.Color.Lerp(color81, Microsoft.Xna.Framework.Color.Black, 0.5f);
                    color87.A = color81.A;
                    float num319 = 0.95f + (proj.rotation * 0.75f).ToRotationVector2().Y * 0.1f;
                    color87 *= num319;
                    float scale10 = 0.6f + proj.scale * 0.6f * num319;
                    EntitySpriteDraw(TextureAssets.Extra[50].Value, vector73, null, color87, 0f - proj.rotation + 0.35f, origin21, scale10, dir ^ SpriteEffects.FlipHorizontally);
                    EntitySpriteDraw(TextureAssets.Extra[50].Value, vector73, null, color81, 0f - proj.rotation, origin21, proj.scale, dir ^ SpriteEffects.FlipHorizontally);
                    EntitySpriteDraw(value83, vector73, null, color86, (0f - proj.rotation) * 0.7f, origin21, proj.scale, dir ^ SpriteEffects.FlipHorizontally);
                    EntitySpriteDraw(TextureAssets.Extra[50].Value, vector73, null, color81 * 0.8f, proj.rotation * 0.5f, origin21, proj.scale * 0.9f, dir);
                    color81.A = 0;
                }
                if (proj.type == 757 || proj.type == 25 || proj.type == 35 || proj.type == 63 || proj.type == 154 || proj.type == 247 || proj.type == 26)
                {
                    if (proj.ai[0] == 1f)
                    {
                        Microsoft.Xna.Framework.Color color88 = color81;
                        color88.A = 127;
                        color88 *= 0.5f;
                        int num320 = (int)proj.ai[1];
                        if (num320 > 5)
                        {
                            num320 = 5;
                        }
                        for (float num321 = 1f; num321 >= 0f; num321 -= 0.125f)
                        {
                            float num322 = 1f - num321;
                            Vector2 vector79 = proj.velocity * -num320 * num321;
                            EntitySpriteDraw(value83, vector73 + vector79, null, color88 * num322, num315, origin21, proj.scale * 1.15f * MathHelper.Lerp(0.5f, 1f, num322), dir);
                        }
                    }
                }
                else if (proj.type == 79)
                {
                    Vector2 scale11 = vector74 * 1.4f;
                    Vector2 spinningpoint6 = new Vector2(2f * scale11.X + (float)Math.Cos(GlobalTimeWrappedHourly * ((float)Math.PI * 2f)) * 0.4f, 0f).RotatedBy(num315 + GlobalTimeWrappedHourly * ((float)Math.PI * 2f));
                    for (float num323 = 0f; num323 < 1f; num323 += 1f / 6f)
                    {
                        Microsoft.Xna.Framework.Color color89 = hslToRgb(num323, 1f, 0.5f) * 0.3f;
                        color89.A = 0;
                        EntitySpriteDraw(value83, vector73 + spinningpoint6.RotatedBy(num323 * ((float)Math.PI * 2f)), null, color89, num315, origin21, scale11, dir);
                    }
                    EntitySpriteDraw(value83, vector73, null, color81, num315, origin21, vector74, dir);
                }
                if ((0u | ((proj.type == 464 && proj.ai[1] != 1f) ? 1u : 0u)) == 0)
                {
                    EntitySpriteDraw(value83, vector73, sourceRectangle5, color81, num315, origin21, vector74, dir);
                }
                if (proj.type == 464 && proj.ai[1] != 1f)
                {
                    value83 = TextureAssets.Extra[35].Value;
                    Microsoft.Xna.Framework.Rectangle rectangle21 = value83.Frame(1, 3);
                    origin21 = rectangle21.Size() / 2f;
                    Vector2 vector80 = new Vector2(0f, -720f).RotatedBy(proj.velocity.ToRotation());
                    float num324 = proj.ai[0] % 45f / 45f;
                    Vector2 spinningpoint7 = vector80 * num324;
                    for (int num325 = 0; num325 < 6; num325++)
                    {
                        float num326 = (float)num325 * ((float)Math.PI * 2f) / 6f;
                        Vector2 vector81 = proj.Center + spinningpoint7.RotatedBy(num326);
                        EntitySpriteDraw(value83, vector81 - screenPosition, rectangle21, color81, num326 + proj.velocity.ToRotation() + (float)Math.PI, origin21, proj.scale, dir);
                        rectangle21.Y += rectangle21.Height;
                        if (rectangle21.Y >= value83.Height)
                        {
                            rectangle21.Y = 0;
                        }
                    }
                }
                else if (proj.type == 490)
                {
                    EntitySpriteDraw(TextureAssets.Extra[34].Value, vector73, null, color81, 0f - proj.rotation, TextureAssets.Extra[34].Value.Size() / 2f, proj.scale, dir);
                    EntitySpriteDraw(value83, vector73, null, color81, proj.rotation, origin21, proj.scale * 0.42f, dir);
                    EntitySpriteDraw(TextureAssets.Extra[34].Value, vector73, null, color81, 0f - proj.rotation, TextureAssets.Extra[34].Value.Size() / 2f, proj.scale * 0.42f, dir);
                }
                else if (proj.type == 616)
                {
                    value83 = TextureAssets.GlowMask[193].Value;
                    EntitySpriteDraw(value83, vector73, null, new Microsoft.Xna.Framework.Color(127, 127, 127, 0), proj.rotation, origin21, proj.scale, dir);
                }
                else if (proj.type >= 646 && proj.type <= 649)
                {
                    value83 = TextureAssets.GlowMask[203 + proj.type - 646].Value;
                    EntitySpriteDraw(value83, vector73, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 127), proj.rotation, origin21, proj.scale, dir);
                }
                else if (proj.type == 699)
                {
                    value83 = TextureAssets.GlowMask[231].Value;
                    EntitySpriteDraw(value83, vector73, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 127), num315, origin21, proj.scale, dir);
                }
                else if (proj.type == 707 || proj.type == 708)
                {
                    float num327 = 0.5f;
                    value83 = TextureAssets.GlowMask[232].Value;
                    Microsoft.Xna.Framework.Rectangle value87 = value83.Frame(1, 3, 0, (int)(proj.ai[0] % 9f) / 3);
                    if (proj.type == 708)
                    {
                        value87 = value83.Frame(1, 3, 0, Main.player[proj.owner].itemAnimation % 9 / 3);
                        num327 = 0.75f;
                    }
                    Microsoft.Xna.Framework.Color color90 = new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * num327;
                    Vector2 spinningpoint8 = new Vector2(2f, 0f).RotatedBy(proj.rotation);
                    for (float num328 = 0f; num328 < 4f; num328 += 1f)
                    {
                        EntitySpriteDraw(value83, vector73 + spinningpoint8.RotatedBy(num328 * ((float)Math.PI / 2f)), value87, color90 * 0.5f, proj.rotation, origin21, proj.scale, dir);
                    }
                    EntitySpriteDraw(value83, vector73, value87, color90, proj.rotation, origin21, proj.scale, dir);
                }
                else if (proj.type == 719)
                {
                    float num329 = 0.3f;
                    Microsoft.Xna.Framework.Color color91 = new Microsoft.Xna.Framework.Color(80, 80, 80, 255) * num329;
                    float num330 = proj.scale * 1.5f;
                    Vector2 spinningpoint9 = new Vector2(2f * num330, 0f).RotatedBy(proj.rotation);
                    for (float num331 = 0f; num331 < 4f; num331 += 1f)
                    {
                        EntitySpriteDraw(value83, vector73 + -proj.velocity * num331 * 1.25f, null, color91 * 0.7f, proj.rotation, origin21, num330, dir);
                    }
                    for (float num332 = 0f; num332 < 3f; num332 += 1f)
                    {
                        EntitySpriteDraw(value83, vector73 + spinningpoint9.RotatedBy(num332 * ((float)Math.PI / 2f)), null, color91 * 0.9f, proj.rotation, origin21, num330, dir);
                    }
                    EntitySpriteDraw(value83, vector73, null, color81, proj.rotation, origin21, proj.scale, dir);
                }
                else if (proj.type == 16)
                {
                    Microsoft.Xna.Framework.Color color92 = new Microsoft.Xna.Framework.Color(80, 80, 80, 0);
                    Vector2 scale12 = vector74 + vector74 * (float)Math.Cos(GlobalTimeWrappedHourly * ((float)Math.PI * 2f)) * 0.4f;
                    Vector2 spinningpoint10 = new Vector2(2f * scale12.X, 0f).RotatedBy(num315);
                    for (float num333 = 0f; num333 < 1f; num333 += 0.25f)
                    {
                        EntitySpriteDraw(value83, vector73 + spinningpoint10.RotatedBy(num333 * ((float)Math.PI * 2f)), null, color92, num315, origin21, scale12, dir);
                    }
                    EntitySpriteDraw(value83, vector73, null, color81, num315, origin21, vector74, dir);
                }
                else if (proj.type == 34)
                {
                    float lerpValue9 = Utils.GetLerpValue(0f, 6f, proj.localAI[0], clamped: true);
                    Microsoft.Xna.Framework.Color color93 = new Microsoft.Xna.Framework.Color(255, 255, 255, 127) * 0.75f;
                    Vector2 scale13 = new Vector2(lerpValue9);
                    Vector2 spinningpoint11 = new Vector2(4f * scale13.X, 0f).RotatedBy(num315);
                    for (float num334 = 0f; num334 < 1f; num334 += 0.25f)
                    {
                        EntitySpriteDraw(value83, vector73 + spinningpoint11.RotatedBy(num334 * ((float)Math.PI * 2f)), sourceRectangle5, color93, num315, origin21, scale13, dir);
                    }
                }
                return;
            }
            if (proj.type == 465 || proj.type == 467 || proj.type == 468 || proj.type == 500 || proj.type == 518 || proj.type == 535 || proj.type == 539 || proj.type == 575 || proj.type == 574 || proj.type == 589 || proj.type == 590 || proj.type == 593 || proj.type == 602 || proj.type == 596 || proj.type == 612 || proj.type == 953 || proj.type == 613 || proj.type == 614 || proj.type == 623 || proj.type == 625 || proj.type == 626 || proj.type == 627 || proj.type == 628 || proj.type == 634 || proj.type == 635 || proj.type == 643 || proj.type == 644 || proj.type == 645 || proj.type == 650 || proj.type == 652 || proj.type == 658 || proj.type == 659 || proj.type == 663 || proj.type == 665 || proj.type == 667 || proj.type == 677 || proj.type == 678 || proj.type == 679 || proj.type == 691 || proj.type == 692 || proj.type == 693 || proj.type == 702 || proj.type == 703 || proj.type == 701 || proj.type == 712 || proj.type == 715 || proj.type == 716 || proj.type == 717 || proj.type == 718 || proj.type == 758 || proj.type == 759 || proj.type == 764 || proj.type == 779 || proj.type == 783 || proj.type == 773 || proj.type == 820 || proj.type == 831 || proj.type == 970 || proj.type == 836 || proj.type == 851 || proj.type == 855 || proj.type == 856 || proj.type == 857 || proj.type == 861 || proj.type == 862 || proj.type == 863 || proj.type == 866 || proj.type == 870 || proj.type == 882 || proj.type == 885 || proj.type == 889 || proj.type == 895 || proj.type == 896 || proj.type == 898 || proj.type == 903 || proj.type == 904 || proj.type == 905 || proj.type == 906 || proj.type == 908 || proj.type == 910 || proj.type == 911 || proj.type == 951 || proj.type == 957 || proj.type == 962 || proj.type == 963 || proj.type == 967 || proj.type == 968 || proj.type == 978 || proj.type == 995 || proj.type == 886 || proj.type == 892)
            {
                Vector2 vector82 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Texture2D texture2D4 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Rectangle rectangle22 = texture2D4.Frame(1, projFrames[proj.type], 0, proj.frame);
                if (proj.type == 963)
                {
                    rectangle22 = texture2D4.Frame(4, projFrames[proj.type], 0, proj.frame);
                }
                if (proj.type == 957)
                {
                    int horizontalFrames = 3;
                    int frameX = proj.frame / projFrames[proj.type];
                    int frameY2 = proj.frame % projFrames[proj.type];
                    rectangle22 = texture2D4.Frame(horizontalFrames, projFrames[proj.type], frameX, frameY2);
                }
                if (proj.type == 962)
                {
                    int verticalFrames = 4;
                    int frameY3 = proj.frame / projFrames[proj.type];
                    int frameX2 = proj.frame % projFrames[proj.type];
                    rectangle22 = texture2D4.Frame(projFrames[proj.type], verticalFrames, frameX2, frameY3);
                }
                Microsoft.Xna.Framework.Color color94 = proj.GetAlpha(projectileColor);
                if (proj.type == 623 && CurrentDrawnEntityShader != 0)
                {
                    color94.A = 127;
                }
                if (proj.type == 995)
                {
                    Projectile.AI_192_GetJuminoFall(proj, out var timeSinceFall, out var fall);
                    vector82.Y -= 4f;
                    vector82.Y += fall;
                    float amount = Utils.Remap(timeSinceFall, 0f, 10f, 1f, 0f);
                    color94 = Microsoft.Xna.Framework.Color.Lerp(color94, Microsoft.Xna.Framework.Color.White * proj.Opacity, amount);
                }
                Vector2 origin25 = rectangle22.Size() / 2f;
                if (proj.type == 703)
                {
                    rectangle22.Height -= 2;
                }
                if (proj.type == 957)
                {
                    float num335 = (float)(Math.Cos((float)(int)mouseTextColor / 255f * ((float)Math.PI * 2f) * 2f) * 4.0);
                    num335 *= Math.Max(0f, Math.Min(1f, proj.localAI[0] / 100f));
                    float num336 = 0f;
                    if (proj.frame > projFrames[proj.type] * 2)
                    {
                        switch (proj.frame % projFrames[proj.type])
                        {
                        case 5:
                        case 11:
                            num336 = 2f;
                            break;
                        case 6:
                        case 10:
                            num336 = 6f;
                            break;
                        case 7:
                            num336 = 8f;
                            break;
                        case 8:
                        case 9:
                            num336 = 10f;
                            break;
                        }
                    }
                    vector82.Y += -2f + num335 + num336;
                }
                if (proj.type == 895 || proj.type == 896 || proj.type == 898 || proj.type == 963)
                {
                    float num337 = 2f;
                    if (proj.isAPreviewDummy)
                    {
                        num337 = 0.5f;
                    }
                    vector82.Y += 0f - num337 + (float)(Math.Cos((float)(int)mouseTextColor / 255f * ((float)Math.PI * 2f) * 2f) * (double)(num337 * 2f));
                }
                if (proj.type == 963 && proj.localAI[1] >= 0f)
                {
                    float num338 = proj.localAI[1];
                    float num339 = 1f - num338;
                    Microsoft.Xna.Framework.Color color95 = proj.GetAlpha(new Microsoft.Xna.Framework.Color(255, 220, 220)) * num339 * num339 * 0.8f;
                    color95.A = 0;
                    short num340 = 536;
                    LoadProjectile(num340);
                    Texture2D value88 = TextureAssets.Projectile[num340].Value;
                    Vector2 origin26 = value88.Size() * new Vector2(0.5f, 1f);
                    float num341 = 9f;
                    float num342 = proj.velocity.ToRotation();
                    if (proj.velocity.Length() < 0.1f)
                    {
                        num342 = ((proj.direction == 1) ? 0f : ((float)Math.PI));
                    }
                    Vector2 value89 = (num342 + (float)Math.PI / 2f).ToRotationVector2();
                    for (int num343 = 0; (float)num343 < num341; num343++)
                    {
                        float num344 = ((num343 % 2 != 0) ? 1 : (-1));
                        float num345 = ((float)num343 + 1f) * num344 * 0.2f * (0.2f + 2f * num338) + num342 + (float)Math.PI / 2f;
                        float num346 = Utils.Remap(Vector2.Dot(num345.ToRotationVector2(), value89), -1f, 1f, 0f, 1f);
                        float num347 = proj.scale * (0.15f + 0.6f * (float)Math.Sin(GlobalTimeWrappedHourly + (float)num343 * 0.739f)) * num346;
                        EntitySpriteDraw(value88, vector82 + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI * 2f * (1f / num341) * (float)num343 + GlobalTimeWrappedHourly) * 4f * proj.scale, null, color95 * num346, num345, origin26, new Vector2(num347 * 1.5f, num347), SpriteEffects.None);
                    }
                }
                if (proj.type == 962)
                {
                    float num348 = Utils.Remap(proj.ai[0], 0f, 30f, 1f, 0f);
                    Microsoft.Xna.Framework.Color color96 = proj.GetAlpha(Microsoft.Xna.Framework.Color.White) * num348 * num348 * 0.3f;
                    color96.A = 0;
                    for (int num349 = 0; num349 < 4; num349++)
                    {
                        EntitySpriteDraw(texture2D4, vector82 + proj.rotation.ToRotationVector2().RotatedBy((float)Math.PI / 2f * (float)num349) * 2f * proj.scale, rectangle22, color96, proj.rotation, origin25, proj.scale, dir);
                    }
                }
                if (proj.type == 855)
                {
                    float y21 = (GlobalTimeWrappedHourly % 6f / 6f * ((float)Math.PI * 2f)).ToRotationVector2().Y;
                    float num350 = y21 * 0.3f + 0.7f;
                    Microsoft.Xna.Framework.Color color97 = color94 * num350 * 0.3f;
                    for (int num351 = 0; num351 < 4; num351++)
                    {
                        float x13 = 0f;
                        float y22 = 0f;
                        switch (num351)
                        {
                        case 0:
                            x13 = 4f;
                            break;
                        case 1:
                            x13 = -4f;
                            break;
                        case 2:
                            y22 = 4f;
                            break;
                        case 3:
                            y22 = -4f;
                            break;
                        }
                        Vector2 vector83 = new Vector2(x13, y22).RotatedBy(proj.rotation) * y21;
                        spriteBatch.Draw(texture2D4, vector82 + vector83, rectangle22, color97, proj.rotation, rectangle22.Size() / 2f, 1f, SpriteEffects.None, 0f);
                    }
                }
                else if (proj.type == 908)
                {
                    PlayerTitaniumStormBuffTextureContent playerTitaniumStormBuff = TextureAssets.RenderTargets.PlayerTitaniumStormBuff;
                    vector82 += (GlobalTimeWrappedHourly * 8f + (float)proj.whoAmI).ToRotationVector2() * 4f;
                    playerTitaniumStormBuff.Request();
                    if (playerTitaniumStormBuff.IsReady)
                    {
                        texture2D4 = playerTitaniumStormBuff.GetTarget();
                    }
                    rectangle22 = texture2D4.Frame(projFrames[proj.type], 1, proj.frame);
                    origin25 = rectangle22.Size() / 2f;
                }
                else if (proj.type == 764)
                {
                    DrawProjWithStarryTrail(proj, projectileColor, dir);
                }
                else if (proj.type == 856)
                {
                    DrawProjWithStarryTrail(proj, projectileColor, dir);
                }
                else if (proj.type == 857)
                {
                    DrawProjWithStarryTrail(proj, projectileColor, dir);
                    color94 = Microsoft.Xna.Framework.Color.White * proj.Opacity * 0.9f;
                    color94.A /= 2;
                    rectangle22 = texture2D4.Frame(15, 1, proj.frame);
                    origin25 = rectangle22.Size() / 2f;
                    DrawPrettyStarSparkle(proj.Opacity, dir, vector82, color94, proj.GetFirstFractalColor(), proj.localAI[0], 15f, 30f, 30f, 45f, 0f, new Vector2(5f, 2f), Vector2.One);
                }
                else if (proj.type == 539)
                {
                    if (proj.ai[0] >= 210f)
                    {
                        float num352 = proj.ai[0] - 210f;
                        num352 /= 20f;
                        if (num352 > 1f)
                        {
                            num352 = 1f;
                        }
                        EntitySpriteDraw(TextureAssets.Extra[46].Value, vector82, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 128) * num352, proj.rotation, new Vector2(17f, 22f), proj.scale, dir);
                    }
                }
                else if (proj.type == 773)
                {
                    origin25.Y = rectangle22.Height - 12;
                }
                else if (proj.type == 866)
                {
                    origin25.X += 14f;
                }
                else if (proj.type == 759)
                {
                    origin25.Y = rectangle22.Height - 2;
                    origin25.X += (dir.HasFlag(SpriteEffects.FlipHorizontally) ? 1 : (-1));
                }
                else if (proj.type == 758)
                {
                    vector82.Y += proj.height / 2;
                    origin25 = rectangle22.Size() * new Vector2(0.5f, 1f);
                    origin25.Y -= 4f;
                }
                else if (proj.type == 951)
                {
                    vector82.Y += proj.height / 2;
                    vector82.Y -= (float)rectangle22.Height * 0.5f;
                    vector82.Y += 4f;
                    origin25 = rectangle22.Size() * new Vector2(0.5f, 0.5f);
                }
                else if (proj.type == 833)
                {
                    if (proj.frame != 8)
                    {
                        vector82.Y += proj.height / 2;
                        origin25 = rectangle22.Size() * new Vector2(0.5f, 1f);
                        origin25.Y -= 4f;
                        origin25.X -= 7 * dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt();
                    }
                }
                else if (proj.type == 834 || proj.type == 835)
                {
                    if (proj.frame != 10)
                    {
                        vector82.Y += proj.height / 2;
                        origin25 = rectangle22.Size() * new Vector2(0.5f, 1f);
                        origin25.Y -= 4f;
                        origin25.X -= 2 * dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt();
                    }
                }
                else if (proj.type == 715 || proj.type == 716 || proj.type == 717 || proj.type == 718)
                {
                    rectangle22 = texture2D4.Frame(3);
                    origin25 = rectangle22.Size() / 2f;
                    int num353 = (int)proj.ai[0];
                    Vector2 origin27 = new Vector2(rectangle22.Width / 2, 0f);
                    Vector2 vector84 = proj.Size / 2f;
                    Microsoft.Xna.Framework.Color celeb2Color = proj.GetCeleb2Color();
                    celeb2Color.A = 127;
                    celeb2Color *= 0.8f;
                    Microsoft.Xna.Framework.Rectangle value90 = rectangle22;
                    value90.X += value90.Width * 2;
                    for (int num354 = proj.oldPos.Length - 1; num354 > 0; num354--)
                    {
                        Vector2 vector85 = proj.oldPos[num354] + vector84;
                        if (!(vector85 == vector84))
                        {
                            Vector2 value91 = proj.oldPos[num354 - 1] + vector84;
                            float num355 = proj.oldRot[num354];
                            Vector2 scale14 = new Vector2(Vector2.Distance(vector85, value91) / (float)rectangle22.Width, 1f);
                            Microsoft.Xna.Framework.Color color98 = celeb2Color * (1f - (float)num354 / (float)proj.oldPos.Length);
                            switch (num353)
                            {
                            case 2:
                            {
                                Vector2 vector86 = num355.ToRotationVector2();
                                int num356 = num354 + proj.timeLeft;
                                if (num356 < 0)
                                {
                                    num356 += 20 * (num356 / -20) + 20;
                                }
                                num356 %= 20;
                                float num357 = 0f;
                                scale14 *= 0.6f;
                                switch (num356)
                                {
                                case 1:
                                    num357 = 1f;
                                    break;
                                case 2:
                                    num357 = 2f;
                                    break;
                                case 3:
                                    num357 = 3f;
                                    break;
                                case 4:
                                    num357 = 2f;
                                    break;
                                case 5:
                                    num357 = 1f;
                                    break;
                                case 7:
                                    num357 = -1f;
                                    break;
                                case 8:
                                    num357 = -2f;
                                    break;
                                case 9:
                                    num357 = -3f;
                                    break;
                                case 10:
                                    num357 = -2f;
                                    break;
                                case 11:
                                    num357 = -1f;
                                    break;
                                }
                                vector85 += vector86 * num357 * 4f;
                                break;
                            }
                            case 5:
                                scale14 *= 0.5f;
                                break;
                            }
                            EntitySpriteDraw(texture2D4, vector85 - screenPosition, value90, color98, num355, origin27, scale14, dir);
                        }
                    }
                }
                else if (proj.type == 663 || proj.type == 665 || proj.type == 667)
                {
                    vector82 = proj.Bottom + Vector2.UnitY * proj.gfxOffY - screenPosition;
                    origin25 = rectangle22.Size() * new Vector2(0.5f, 1f);
                    origin25.Y -= 2f;
                    origin25.Y -= 2f;
                }
                else if (proj.type == 691 || proj.type == 692 || proj.type == 693)
                {
                    vector82 = proj.Bottom + Vector2.UnitY * proj.gfxOffY - screenPosition;
                    origin25 = rectangle22.Size() * new Vector2(0.5f, 1f);
                    origin25.Y -= 2f;
                    origin25.Y -= 2f;
                }
                else if (proj.type == 677 || proj.type == 678 || proj.type == 679)
                {
                    if (proj.spriteDirection == -1)
                    {
                        dir ^= SpriteEffects.FlipHorizontally | SpriteEffects.FlipVertically;
                    }
                    Texture2D value92 = TextureAssets.Extra[83].Value;
                    if (proj.type == 678)
                    {
                        value92 = TextureAssets.Extra[84].Value;
                    }
                    if (proj.type == 679)
                    {
                        value92 = TextureAssets.Extra[85].Value;
                    }
                    Vector2 position22 = proj.Bottom + Vector2.UnitY * proj.gfxOffY - screenPosition;
                    Vector2 origin28 = value92.Size() * new Vector2(0.5f, 1f);
                    origin28.Y -= 2f;
                    EntitySpriteDraw(value92, position22, null, color94, 0f, origin28, 1f, dir & SpriteEffects.FlipHorizontally);
                    origin25.X += dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt();
                    vector82.Y += 1f;
                    vector82.Y += 2f;
                    if (proj.type == 678)
                    {
                        vector82.Y += -4f;
                    }
                    if (proj.type == 679)
                    {
                        vector82.Y -= 2f;
                        if (!dir.HasFlag(SpriteEffects.FlipVertically))
                        {
                            origin25.Y += 4f;
                        }
                        else
                        {
                            origin25.Y -= 4f;
                        }
                        origin25.X += dir.HasFlag(SpriteEffects.FlipHorizontally).ToDirectionInt() * 4;
                    }
                }
                else if (proj.type == 602)
                {
                    origin25.X = rectangle22.Width - 6;
                    origin25.Y -= 1f;
                    rectangle22.Height -= 2;
                }
                else if (proj.type == 589)
                {
                    rectangle22 = texture2D4.Frame(5, 1, (int)proj.ai[1]);
                    origin25 = rectangle22.Size() / 2f;
                }
                else if (proj.type == 590)
                {
                    if (proj.ai[2] == 1f && proj.frame < 3)
                    {
                        proj.frame = 3;
                    }
                    rectangle22 = texture2D4.Frame(6, 1, proj.frame);
                    origin25 = rectangle22.Size() / 2f;
                }
                else if (proj.type == 836)
                {
                    rectangle22 = texture2D4.Frame(4, 1, proj.frame);
                    origin25 = rectangle22.Size() / 2f;
                }
                else if (proj.type == 650 || proj.type == 882 || proj.type == 888 || proj.type == 894 || proj.type == 895 || proj.type == 896 || proj.type == 898 || proj.type == 901 || proj.type == 957)
                {
                    origin25.Y -= 4f;
                }
                else if (proj.type == 623)
                {
                    if (!gamePaused && proj.ai[0] == 2f)
                    {
                        vector82 += rand.NextVector2Circular(2f, 2f);
                    }
                    if (CurrentDrawnEntityShader == 0)
                    {
                        color94.A /= 2;
                    }
                }
                else if (proj.type >= 625 && proj.type <= 628)
                {
                    color94.A /= 2;
                }
                else if (proj.type == 644)
                {
                    Microsoft.Xna.Framework.Color color99 = hslToRgb(proj.ai[0], 1f, 0.5f).MultiplyRGBA(new Microsoft.Xna.Framework.Color(255, 255, 255, 0));
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, color99, proj.rotation, origin25, proj.scale * 2f, dir);
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, color99, 0f, origin25, proj.scale * 2f, dir);
                    if (proj.ai[1] != -1f && proj.Opacity > 0.3f)
                    {
                        Vector2 vector87 = Main.projectile[(int)proj.ai[1]].Center - proj.Center;
                        Vector2 vector88 = new Vector2(1f, vector87.Length() / (float)texture2D4.Height);
                        float rotation29 = vector87.ToRotation() + (float)Math.PI / 2f;
                        float value93 = MathHelper.Distance(30f, proj.localAI[1]) / 20f;
                        value93 = MathHelper.Clamp(value93, 0f, 1f);
                        if (value93 > 0f)
                        {
                            EntitySpriteDraw(texture2D4, vector82 + vector87 / 2f, rectangle22, color99 * value93, rotation29, origin25, vector88, dir);
                            EntitySpriteDraw(texture2D4, vector82 + vector87 / 2f, rectangle22, color94 * value93, rotation29, origin25, vector88 / 2f, dir);
                        }
                    }
                }
                else if (proj.type == 658)
                {
                    Microsoft.Xna.Framework.Color color100 = hslToRgb(0.136f, 1f, 0.5f).MultiplyRGBA(new Microsoft.Xna.Framework.Color(255, 255, 255, 0));
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, color100, 0f, origin25, new Vector2(1f, 5f) * proj.scale * 2f, dir);
                }
                EntitySpriteDraw(texture2D4, vector82, rectangle22, color94, proj.rotation, origin25, proj.scale, dir);
                if (proj.type == 896)
                {
                    Texture2D value94 = TextureAssets.GlowMask[278].Value;
                    Microsoft.Xna.Framework.Color color101 = new Microsoft.Xna.Framework.Color(150, 150, 150, 100);
                    for (int num358 = 0; num358 < 2; num358++)
                    {
                        Vector2 position23 = vector82 + new Vector2((float)rand.Next(-10, 11) * 0.1f, (float)rand.Next(-10, 11) * 0.1f);
                        EntitySpriteDraw(value94, position23, rectangle22, color101, proj.rotation, origin25, proj.scale, dir);
                    }
                    EntitySpriteDraw(value94, vector82, rectangle22, Microsoft.Xna.Framework.Color.White, proj.rotation, origin25, proj.scale, dir);
                }
                if (proj.type == 889)
                {
                    Texture2D value95 = TextureAssets.GlowMask[276].Value;
                    Microsoft.Xna.Framework.Color color102 = Microsoft.Xna.Framework.Color.White * (int)mouseTextColor;
                    EntitySpriteDraw(value95, vector82, rectangle22, color102, proj.rotation, origin25, proj.scale, dir);
                    if (!proj.isAPreviewDummy)
                    {
                        for (int num359 = 0; num359 < 4; num359++)
                        {
                            int num360 = 28;
                            int num361 = 7 + num359;
                            float num362 = 100f;
                            bool flag37 = num361 == 8;
                            Microsoft.Xna.Framework.Rectangle value96 = texture2D4.Frame(1, projFrames[proj.type], 0, num361);
                            Vector2 value97 = vector82;
                            Vector2 vector89 = vector82;
                            SpriteEffects effects5 = SpriteEffects.None;
                            float num363 = 0f;
                            float num364 = GlobalTimeWrappedHourly * 2f;
                            switch (num359)
                            {
                            case 1:
                                num364 += (float)Math.PI / 2f;
                                break;
                            case 2:
                                num364 += (float)Math.PI;
                                break;
                            case 3:
                                num364 += 4.712389f;
                                break;
                            }
                            num364 *= 3f;
                            num363 = num364;
                            vector89 += num364.ToRotationVector2() * num360;
                            if (proj.localAI[0] == num362)
                            {
                                EntitySpriteDraw(texture2D4, vector89, value96, color94, num363, origin25, proj.scale, effects5);
                                if (flag37)
                                {
                                    EntitySpriteDraw(value95, vector89, value96, color102, num363, origin25, proj.scale, effects5);
                                }
                                continue;
                            }
                            Vector2 vector90 = new Vector2(num360, -16f) + proj.velocity * 1.5f;
                            float num365 = 4f;
                            float num366 = -0.35f;
                            switch (num359)
                            {
                            case 1:
                                vector90.X *= -1f;
                                effects5 = SpriteEffects.FlipHorizontally;
                                num366 = 0.35f;
                                num365 = -3f;
                                break;
                            case 2:
                                vector90.Y = 16f;
                                num366 = 0.35f;
                                num365 = 2f;
                                break;
                            case 3:
                                vector90.X *= -1f;
                                vector90.Y = 16f;
                                effects5 = SpriteEffects.FlipHorizontally;
                                num366 = -0.35f;
                                num365 = -1f;
                                break;
                            }
                            vector90 += (GlobalTimeWrappedHourly * num365).ToRotationVector2() * 4f;
                            value97 += vector90;
                            float num367 = proj.localAI[0] / num362;
                            value97 = Vector2.Lerp(value97, vector89, num367);
                            num363 = ((num367 > 0.5f) ? num364 : num366);
                            EntitySpriteDraw(texture2D4, value97, value96, color94, num363, origin25, proj.scale, effects5);
                            if (flag37)
                            {
                                EntitySpriteDraw(value95, value97, value96, color102, num363, origin25, proj.scale, effects5);
                            }
                        }
                    }
                }
                if (proj.type == 885 && !proj.isAPreviewDummy)
                {
                    for (int num368 = 0; num368 < 2; num368++)
                    {
                        SpriteEffects effects6 = SpriteEffects.None;
                        int num369 = -30;
                        if (num368 == 1)
                        {
                            num369 = 30;
                            effects6 = SpriteEffects.FlipHorizontally;
                        }
                        int num370 = (int)proj.localAI[0];
                        if (proj.frame == 6)
                        {
                            num370 = 0;
                        }
                        else if (num368 == 1)
                        {
                            num370 = 2 - num370;
                        }
                        num370 += 7;
                        Microsoft.Xna.Framework.Rectangle value98 = texture2D4.Frame(1, projFrames[proj.type], 0, num370);
                        Vector2 position24 = vector82 + new Vector2(num369, 0f);
                        Vector2 vector91 = (GlobalTimeWrappedHourly * 2f).ToRotationVector2() * 4f;
                        vector91 += proj.velocity * -1.5f;
                        Vector2 vector92 = (GlobalTimeWrappedHourly * 1f).ToRotationVector2() * 3f;
                        if (num368 == 1)
                        {
                            position24 += vector91 + vector92;
                        }
                        else
                        {
                            position24 -= vector91;
                        }
                        EntitySpriteDraw(texture2D4, position24, value98, color94, 0f, origin25, proj.scale, effects6);
                    }
                }
                if (proj.type == 535)
                {
                    for (int num371 = 0; num371 < 1000; num371++)
                    {
                        if (Main.projectile[num371].active && Main.projectile[num371].owner == proj.owner && Main.projectile[num371].type == 536)
                        {
                            DrawProj(num371);
                        }
                    }
                }
                else if (proj.type == 715 || proj.type == 716 || proj.type == 717 || proj.type == 718)
                {
                    rectangle22.X += rectangle22.Width;
                    Microsoft.Xna.Framework.Color celeb2Color2 = proj.GetCeleb2Color();
                    celeb2Color2.A = 80;
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, celeb2Color2, proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 702)
                {
                    Texture2D value99 = TextureAssets.Flames[5].Value;
                    Vector2 origin29 = value99.Size() / 2f;
                    Vector2 vector93 = new Vector2(5 * proj.spriteDirection, -10f).RotatedBy(proj.rotation);
                    ulong seed2 = (ulong)(proj.localAI[0] / 4f);
                    for (int num372 = 0; num372 < 5; num372++)
                    {
                        Microsoft.Xna.Framework.Color color103 = new Microsoft.Xna.Framework.Color(100, 100, 100, 0);
                        float x14 = (float)Utils.RandomInt(ref seed2, -10, 11) * 0.15f;
                        float y23 = (float)Utils.RandomInt(ref seed2, -10, 1) * 0.35f;
                        EntitySpriteDraw(value99, vector82 + vector93 + new Vector2(x14, y23), null, color103, proj.rotation, origin29, 1f, dir);
                    }
                }
                else if (proj.type == 663 || proj.type == 665 || proj.type == 667)
                {
                    Texture2D value100 = TextureAssets.GlowMask[221].Value;
                    switch (proj.type)
                    {
                    case 665:
                        value100 = TextureAssets.GlowMask[222].Value;
                        break;
                    case 667:
                        value100 = TextureAssets.GlowMask[223].Value;
                        break;
                    }
                    float num373 = (proj.localAI[0] / 100f * ((float)Math.PI * 2f)).ToRotationVector2().X * 1f + 1f;
                    Microsoft.Xna.Framework.Color color104 = new Microsoft.Xna.Framework.Color(140, 100, 40, 0) * (num373 / 4f + 0.5f) * 1f;
                    for (float num374 = 0f; num374 < 4f; num374 += 1f)
                    {
                        EntitySpriteDraw(value100, vector82 + (num374 * ((float)Math.PI / 2f)).ToRotationVector2() * num373, rectangle22, color104, proj.rotation, origin25, proj.scale, dir);
                    }
                }
                else if (proj.type == 644)
                {
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, color94, 0f, origin25, proj.scale, dir);
                }
                else if (proj.type == 963)
                {
                    int num375 = Main.player[proj.owner].ownedProjectileCounts[970] - 1;
                    int num376 = (num375 + 3) % 3;
                    int num377 = num375 / 3;
                    Vector3 vector94 = rgbToHsl(new Microsoft.Xna.Framework.Color(250, 150, 180));
                    vector94 = new Vector3(0f, 1f, 0.6f);
                    if (num377 == 1)
                    {
                        vector94 = rgbToHsl(Microsoft.Xna.Framework.Color.HotPink);
                        vector94.Z += 0.1f;
                        vector94.X -= 0.05f;
                    }
                    vector94.X = (vector94.X - (float)num377 * 0.13f + 1f) % 1f;
                    Microsoft.Xna.Framework.Color oldColor = hslToRgb(vector94);
                    Microsoft.Xna.Framework.Color color105 = Lighting.GetColor((int)(proj.Center.X / 16f), (int)(proj.Center.Y / 16f), oldColor);
                    rectangle22.X += rectangle22.Width * (1 + num376);
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, color105, proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 773 && proj.velocity.Length() == 0f)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[266].Value, color: Microsoft.Xna.Framework.Color.White * (int)mouseTextColor, position: vector82, sourceRectangle: rectangle22, rotation: proj.rotation, origin: origin25, scale: proj.scale, effects: dir);
                }
                else if (proj.type == 658)
                {
                    EntitySpriteDraw(texture2D4, vector82, rectangle22, color94, 0f, origin25, new Vector2(1f, 8f) * proj.scale, dir);
                }
                else if (proj.type == 602)
                {
                    texture2D4 = TextureAssets.Extra[60].Value;
                    Microsoft.Xna.Framework.Color color107 = color94;
                    color107.A = 0;
                    color107 *= 0.3f;
                    origin25 = texture2D4.Size() / 2f;
                    EntitySpriteDraw(texture2D4, vector82, null, color107, proj.rotation - (float)Math.PI / 2f, origin25, proj.scale, dir);
                    texture2D4 = TextureAssets.Extra[59].Value;
                    color107 = color94;
                    color107.A = 0;
                    color107 *= 0.13f;
                    origin25 = texture2D4.Size() / 2f;
                    EntitySpriteDraw(texture2D4, vector82, null, color107, proj.rotation - (float)Math.PI / 2f, origin25, proj.scale * 0.9f, dir);
                }
                else if (proj.type == 539)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[140].Value, vector82, rectangle22, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 613)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[189].Value, vector82, rectangle22, new Microsoft.Xna.Framework.Color(128 - proj.alpha / 2, 128 - proj.alpha / 2, 128 - proj.alpha / 2, 0), proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 614)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[190].Value, vector82, rectangle22, new Microsoft.Xna.Framework.Color(128 - proj.alpha / 2, 128 - proj.alpha / 2, 128 - proj.alpha / 2, 0), proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 574)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[148].Value, vector82, rectangle22, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 691 || proj.type == 692 || proj.type == 693)
                {
                    Texture2D value102 = TextureAssets.GlowMask[235].Value;
                    switch (proj.type)
                    {
                    case 692:
                        value102 = TextureAssets.GlowMask[236].Value;
                        break;
                    case 693:
                        value102 = TextureAssets.GlowMask[237].Value;
                        break;
                    }
                    EntitySpriteDraw(value102, vector82, rectangle22, new Microsoft.Xna.Framework.Color(255, 255, 255, 127), proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 590)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[168].Value, vector82, rectangle22, new Microsoft.Xna.Framework.Color(127 - proj.alpha / 2, 127 - proj.alpha / 2, 127 - proj.alpha / 2, 0), proj.rotation, origin25, proj.scale, dir);
                }
                else if (proj.type == 623 || (proj.type >= 625 && proj.type <= 628))
                {
                    if (Main.player[proj.owner].ghostFade != 0f)
                    {
                        float num378 = Main.player[proj.owner].ghostFade * 5f;
                        for (float num379 = 0f; num379 < 4f; num379 += 1f)
                        {
                            EntitySpriteDraw(texture2D4, vector82 + Vector2.UnitY.RotatedBy(num379 * ((float)Math.PI * 2f) / 4f) * num378, rectangle22, color94 * 0.1f, proj.rotation, origin25, proj.scale, dir);
                        }
                    }
                    if (proj.type == 623 && proj.ai[0] == 2f && proj.frame >= 14)
                    {
                        DrawProj_StardustGuardianPunching(proj);
                    }
                }
                else if (proj.type == 643)
                {
                    float num380 = (float)Math.Cos((float)Math.PI * 2f * (proj.localAI[0] / 60f)) + 3f + 3f;
                    for (float num381 = 0f; num381 < 4f; num381 += 1f)
                    {
                        EntitySpriteDraw(texture2D4, vector82 + Vector2.UnitY.RotatedBy(num381 * ((float)Math.PI / 2f)) * num380, rectangle22, color94 * 0.2f, proj.rotation, origin25, proj.scale, dir);
                    }
                }
                else if (proj.type == 650)
                {
                    int num382 = (int)(proj.localAI[0] / ((float)Math.PI * 2f));
                    float f = proj.localAI[0] % ((float)Math.PI * 2f) - (float)Math.PI;
                    float num383 = (float)Math.IEEERemainder(proj.localAI[1], 1.0);
                    if (num383 < 0f)
                    {
                        num383 += 1f;
                    }
                    int num384 = (int)Math.Floor(proj.localAI[1]);
                    float num385 = 1f;
                    float num386 = 5f;
                    num385 = 1f + (float)num384 * 0.02f;
                    if ((float)num382 == 1f)
                    {
                        num386 = 7f;
                    }
                    Vector2 vector95 = f.ToRotationVector2() * num383 * num386 * proj.scale;
                    texture2D4 = TextureAssets.Extra[66].Value;
                    EntitySpriteDraw(texture2D4, vector82 + vector95, null, color94, proj.rotation, texture2D4.Size() / 2f, num385, SpriteEffects.None);
                }
                return;
            }
            if (proj.type == 466)
            {
                Vector2 end = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Texture2D value103 = TextureAssets.Extra[33].Value;
                proj.GetAlpha(projectileColor);
                Vector2 vector96 = new Vector2(proj.scale) / 2f;
                for (int num387 = 0; num387 < 3; num387++)
                {
                    switch (num387)
                    {
                    case 0:
                        vector96 = new Vector2(proj.scale) * 0.6f;
                        DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(115, 204, 219, 0) * 0.5f;
                        break;
                    case 1:
                        vector96 = new Vector2(proj.scale) * 0.4f;
                        DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(113, 251, 255, 0) * 0.5f;
                        break;
                    default:
                        vector96 = new Vector2(proj.scale) * 0.2f;
                        DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.5f;
                        break;
                    }
                    DelegateMethods.f_1 = 1f;
                    for (int num388 = proj.oldPos.Length - 1; num388 > 0; num388--)
                    {
                        if (!(proj.oldPos[num388] == Vector2.Zero))
                        {
                            Vector2 start = proj.oldPos[num388] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                            Vector2 end2 = proj.oldPos[num388 - 1] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                            Utils.DrawLaser(spriteBatch, value103, start, end2, vector96, DelegateMethods.LightningLaserDraw);
                        }
                    }
                    if (proj.oldPos[0] != Vector2.Zero)
                    {
                        DelegateMethods.f_1 = 1f;
                        Vector2 start2 = proj.oldPos[0] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                        Utils.DrawLaser(spriteBatch, value103, start2, end, vector96, DelegateMethods.LightningLaserDraw);
                    }
                }
                return;
            }
            if (proj.type == 580)
            {
                Vector2 end3 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Texture2D value104 = TextureAssets.Extra[33].Value;
                proj.GetAlpha(projectileColor);
                Vector2 vector97 = new Vector2(proj.scale) / 2f;
                for (int num389 = 0; num389 < 2; num389++)
                {
                    float num390 = ((proj.localAI[1] == -1f || proj.localAI[1] == 1f) ? (-0.2f) : 0f);
                    if (num389 == 0)
                    {
                        vector97 = new Vector2(proj.scale) * (0.5f + num390);
                        DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(115, 244, 219, 0) * 0.5f;
                    }
                    else
                    {
                        vector97 = new Vector2(proj.scale) * (0.3f + num390);
                        DelegateMethods.c_1 = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.5f;
                    }
                    DelegateMethods.f_1 = 1f;
                    for (int num391 = proj.oldPos.Length - 1; num391 > 0; num391--)
                    {
                        if (!(proj.oldPos[num391] == Vector2.Zero))
                        {
                            Vector2 start3 = proj.oldPos[num391] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                            Vector2 end4 = proj.oldPos[num391 - 1] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                            Utils.DrawLaser(spriteBatch, value104, start3, end4, vector97, DelegateMethods.LightningLaserDraw);
                        }
                    }
                    if (proj.oldPos[0] != Vector2.Zero)
                    {
                        DelegateMethods.f_1 = 1f;
                        Vector2 start4 = proj.oldPos[0] + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                        Utils.DrawLaser(spriteBatch, value104, start4, end3, vector97, DelegateMethods.LightningLaserDraw);
                    }
                }
                return;
            }
            if (proj.type == 445)
            {
                if (Main.player[proj.owner].gravDir == -1f)
                {
                    dir |= SpriteEffects.FlipVertically;
                }
                Vector2 vector98 = proj.position + new Vector2(proj.width, proj.height) / 2f + Vector2.UnitY * proj.gfxOffY - screenPosition;
                Texture2D value105 = TextureAssets.Projectile[proj.type].Value;
                Microsoft.Xna.Framework.Color alpha10 = proj.GetAlpha(projectileColor);
                Vector2 vector99 = Main.player[proj.owner].RotatedRelativePoint(mountedCenter) + Vector2.UnitY * Main.player[proj.owner].gfxOffY;
                Vector2 vector100 = vector98 + screenPosition - vector99;
                Vector2 vector101 = Vector2.Normalize(vector100);
                float num392 = vector100.Length();
                float num393 = vector100.ToRotation() + (float)Math.PI / 2f;
                float num394 = -5f;
                float num395 = num394 + 30f;
                new Vector2(2f, num392 - num395);
                Vector2 vector102 = Vector2.Lerp(vector98 + screenPosition, vector99 + vector101 * num395, 0.5f);
                Vector2 vector103 = -Vector2.UnitY.RotatedBy(proj.localAI[0] / 60f * (float)Math.PI);
                Vector2[] array7 = new Vector2[4]
                {
                    vector103,
                    vector103.RotatedBy(1.5707963705062866),
                    vector103.RotatedBy(3.1415927410125732),
                    vector103.RotatedBy(4.71238899230957)
                };
                if (num392 > num395)
                {
                    for (int num396 = 0; num396 < 2; num396++)
                    {
                        Microsoft.Xna.Framework.Color white4 = Microsoft.Xna.Framework.Color.White;
                        if (num396 % 2 == 0)
                        {
                            white4 = Microsoft.Xna.Framework.Color.LimeGreen;
                            white4.A = 128;
                            white4 *= 0.5f;
                        }
                        else
                        {
                            white4 = Microsoft.Xna.Framework.Color.CornflowerBlue;
                            white4.A = 128;
                            white4 *= 0.5f;
                        }
                        Vector2 vector104 = new Vector2(array7[num396].X, 0f).RotatedBy(num393) * 4f;
                        EntitySpriteDraw(TextureAssets.MagicPixel.Value, vector102 - screenPosition + vector104, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), white4, num393, Vector2.One / 2f, new Vector2(2f, num392 - num395), dir);
                    }
                }
                int type2 = Main.player[proj.owner].inventory[Main.player[proj.owner].selectedItem].type;
                instance.LoadItem(type2);
                Texture2D value106 = TextureAssets.Item[type2].Value;
                Microsoft.Xna.Framework.Color color108 = Lighting.GetColor((int)vector99.X / 16, (int)vector99.Y / 16);
                EntitySpriteDraw(value106, vector99 - screenPosition + vector101 * num394, null, color108, proj.rotation + (float)Math.PI / 2f + ((dir == SpriteEffects.None || dir == SpriteEffects.FlipVertically) ? ((float)Math.PI) : 0f), new Vector2((dir != 0 && dir != SpriteEffects.FlipVertically) ? value106.Width : 0, (float)value106.Height / 2f) + Vector2.UnitY * 1f, Main.player[proj.owner].inventory[Main.player[proj.owner].selectedItem].scale, dir);
                EntitySpriteDraw(TextureAssets.GlowMask[39].Value, vector99 - screenPosition + vector101 * num394, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 0), proj.rotation + (float)Math.PI / 2f + ((dir == SpriteEffects.None || dir == SpriteEffects.FlipVertically) ? ((float)Math.PI) : 0f), new Vector2((dir != 0 && dir != SpriteEffects.FlipVertically) ? value106.Width : 0, (float)value106.Height / 2f) + Vector2.UnitY * 1f, Main.player[proj.owner].inventory[Main.player[proj.owner].selectedItem].scale, dir);
                if (num392 > num395)
                {
                    for (int num397 = 2; num397 < 4; num397++)
                    {
                        Microsoft.Xna.Framework.Color white5 = Microsoft.Xna.Framework.Color.White;
                        if (num397 % 2 == 0)
                        {
                            white5 = Microsoft.Xna.Framework.Color.LimeGreen;
                            white5.A = 128;
                            white5 *= 0.5f;
                        }
                        else
                        {
                            white5 = Microsoft.Xna.Framework.Color.CornflowerBlue;
                            white5.A = 128;
                            white5 *= 0.5f;
                        }
                        Vector2 vector105 = new Vector2(array7[num397].X, 0f).RotatedBy(num393) * 4f;
                        EntitySpriteDraw(TextureAssets.MagicPixel.Value, vector102 - screenPosition + vector105, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), white5, num393, Vector2.One / 2f, new Vector2(2f, num392 - num395), dir);
                    }
                }
                float num398 = proj.localAI[0] / 60f;
                if (num398 > 0.5f)
                {
                    num398 = 1f - num398;
                }
                EntitySpriteDraw(value105, vector98, null, alpha10 * num398 * 2f, proj.rotation, new Vector2(value105.Width, value105.Height) / 2f, proj.scale, dir);
                EntitySpriteDraw(TextureAssets.GlowMask[40].Value, vector98, null, alpha10 * (0.5f - num398) * 2f, proj.rotation, new Vector2(value105.Width, value105.Height) / 2f, proj.scale, dir);
                return;
            }
            if ((proj.type >= 393 && proj.type <= 395) || proj.type == 398 || proj.type == 423 || proj.type == 450)
            {
                Texture2D value107 = TextureAssets.Projectile[proj.type].Value;
                int num399 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y24 = num399 * proj.frame;
                EntitySpriteDraw(value107, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY - 2f), new Microsoft.Xna.Framework.Rectangle(0, y24, value107.Width, num399), proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value107.Width / 2f, (float)num399 / 2f), proj.scale, dir);
                if (proj.type == 398)
                {
                    value107 = TextureAssets.MiniMinotaur.Value;
                    EntitySpriteDraw(value107, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY - 2f), new Microsoft.Xna.Framework.Rectangle(0, y24, value107.Width, num399), new Microsoft.Xna.Framework.Color(250, 250, 250, proj.alpha), proj.rotation, new Vector2((float)value107.Width / 2f, (float)num399 / 2f), proj.scale, dir);
                }
                if (proj.type == 423)
                {
                    value107 = TextureAssets.GlowMask[0].Value;
                    EntitySpriteDraw(value107, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY - 2f), new Microsoft.Xna.Framework.Rectangle(0, y24, value107.Width, num399), new Microsoft.Xna.Framework.Color(250, 250, 250, proj.alpha), proj.rotation, new Vector2((float)value107.Width / 2f, (float)num399 / 2f), proj.scale, dir);
                }
                return;
            }
            if (proj.type == 385)
            {
                Texture2D value108 = TextureAssets.Projectile[proj.type].Value;
                int num400 = value108.Height / projFrames[proj.type];
                int y25 = num400 * proj.frame;
                int num401 = 8;
                int num402 = 2;
                float value109 = 0.4f;
                for (int num403 = 1; num403 < num401; num403 += num402)
                {
                    _ = ref proj.oldPos[num403];
                    Microsoft.Xna.Framework.Color newColor3 = projectileColor;
                    newColor3 = proj.GetAlpha(newColor3);
                    newColor3 *= (float)(num401 - num403) / 15f;
                    Microsoft.Xna.Framework.Color alpha11 = proj.GetAlpha(projectileColor);
                    _ = proj.oldPos[num403] - screenPosition + new Vector2(num138 + (float)num137, (float)(proj.height / 2) + proj.gfxOffY);
                    EntitySpriteDraw(value108, proj.oldPos[num403] + new Vector2(proj.width, proj.height) / 2f - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y25, value108.Width, num400), Microsoft.Xna.Framework.Color.Lerp(alpha11, newColor3, 0.3f), proj.rotation, new Vector2((float)value108.Width / 2f, (float)num400 / 2f), MathHelper.Lerp(proj.scale, value109, (float)num403 / 15f), dir);
                }
                EntitySpriteDraw(value108, proj.Center - screenPosition + new Vector2(0f, proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y25, value108.Width, num400), proj.GetAlpha(projectileColor), proj.rotation, new Vector2((float)value108.Width / 2f, (float)num400 / 2f), proj.scale, dir);
                return;
            }
            if (proj.type == 388)
            {
                Texture2D value110 = TextureAssets.Projectile[proj.type].Value;
                int num404 = value110.Height / projFrames[proj.type];
                int y26 = num404 * proj.frame;
                int num405 = 0;
                int num406 = 0;
                if (proj.ai[0] == 2f)
                {
                    num405 = 10;
                    num406 = 1;
                }
                else
                {
                    num405 = 3;
                    num406 = 1;
                }
                for (int num407 = 1; num407 < num405; num407 += num406)
                {
                    _ = ref proj.oldPos[num407];
                    Microsoft.Xna.Framework.Color newColor4 = projectileColor;
                    newColor4 = proj.GetAlpha(newColor4);
                    newColor4 *= (float)(num405 - num407) / 15f;
                    Vector2 position25 = proj.oldPos[num407] - screenPosition + new Vector2(num138 + (float)num137, (float)(proj.height / 2) + proj.gfxOffY);
                    EntitySpriteDraw(value110, position25, new Microsoft.Xna.Framework.Rectangle(0, y26, value110.Width, num404), newColor4, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                EntitySpriteDraw(value110, proj.position - screenPosition + new Vector2(num138 + (float)num137, (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y26, value110.Width, num404), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                return;
            }
            if (projFrames[proj.type] > 1)
            {
                int num408 = TextureAssets.Projectile[proj.type].Height() / projFrames[proj.type];
                int y27 = num408 * proj.frame;
                if (proj.type == 111)
                {
                    int r = Main.player[proj.owner].shirtColor.R;
                    int g = Main.player[proj.owner].shirtColor.G;
                    int b = Main.player[proj.owner].shirtColor.B;
                    projectileColor = Lighting.GetColor(oldColor: new Microsoft.Xna.Framework.Color((byte)r, (byte)g, (byte)b), x: (int)((double)proj.position.X + (double)proj.width * 0.5) / 16, y: (int)(((double)proj.position.Y + (double)proj.height * 0.5) / 16.0));
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    return;
                }
                Microsoft.Xna.Framework.Color alpha12 = proj.GetAlpha(projectileColor);
                if (proj.type == 211 && CurrentDrawnEntityShader != 0)
                {
                    alpha12.A = 127;
                }
                if (proj.type == 344)
                {
                    float num409 = MathHelper.Min(60f, proj.ai[0]) / 2f;
                    for (float num410 = 0.9f; num410 > 0f; num410 -= 0.25f)
                    {
                        Vector2 vector106 = num410 * (proj.velocity * 0.33f) * num409;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY) - vector106, new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), alpha12 * (1f - num410) * 0.75f, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale * (0.4f + (1f - num410) * 0.6f), dir);
                    }
                }
                if (proj.type == 920 || proj.type == 921)
                {
                    for (float num411 = 0.25f; num411 < 1f; num411 += 0.5f)
                    {
                        Vector2 vector107 = num411 * proj.velocity * 4f;
                        EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY) - vector107, new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), alpha12 * (1f - num411) * 0.75f, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    }
                }
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), alpha12, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                if (proj.type == 966)
                {
                    Vector2 vector108 = new Vector2(0f, -30f);
                    vector108.Y += -1f + (float)(Math.Cos((float)(int)mouseTextColor / 255f * ((float)Math.PI * 2f) * 2f) * 2.0);
                    Vector2 vector109 = new Vector2(-1f, -1f);
                    float num412 = 3f;
                    Vector2 vector110 = proj.Center + vector108;
                    Vector2 vector111 = proj.Center;
                    int num413 = (int)proj.ai[1];
                    if (num413 >= 0)
                    {
                        if (npc[num413].active)
                        {
                            vector111 = npc[num413].Center;
                        }
                        else
                        {
                            num413 = -1;
                        }
                    }
                    if (num413 <= -1)
                    {
                        Player player5 = Main.player[proj.owner];
                        vector111 = ((!player5.dead) ? player5.Center : (vector110 + new Vector2(2f, 0f)));
                    }
                    vector109 += (vector111 - vector110).SafeNormalize(Vector2.Zero) * num412;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY) + vector108, new Microsoft.Xna.Framework.Rectangle(0, num408, TextureAssets.Projectile[proj.type].Width(), num408 - 1), alpha12, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY) + vector108 + vector109, new Microsoft.Xna.Framework.Rectangle(0, num408 * 2, TextureAssets.Projectile[proj.type].Width(), num408 - 1), alpha12, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                if (proj.type == 335)
                {
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), new Microsoft.Xna.Framework.Color(100, 100, 100, 0), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                if (proj.type == 897 || proj.type == 899)
                {
                    int num414 = 279;
                    if (proj.type == 899)
                    {
                        num414 = 281;
                    }
                    EntitySpriteDraw(TextureAssets.GlowMask[num414].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), Microsoft.Xna.Framework.Color.White, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                if (proj.type == 891)
                {
                    float num415 = Utils.WrappedLerp(0.6f, 1f, (float)((int)timeForVisualEffects % 100) / 100f);
                    EntitySpriteDraw(color: new Microsoft.Xna.Framework.Color(num415, num415, num415, 150f), texture: TextureAssets.GlowMask[277].Value, position: new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), sourceRectangle: new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), rotation: proj.rotation, origin: new Vector2(num138, proj.height / 2 + num136), scale: proj.scale, effects: dir);
                }
                if (proj.type == 595)
                {
                    Player player6 = Main.player[proj.owner];
                    if (player6.active && player6.body == 208)
                    {
                        for (float num416 = 0f; num416 <= 1f; num416 += 0.2f)
                        {
                            Microsoft.Xna.Framework.Color underShirtColor = player6.underShirtColor;
                            underShirtColor.A = (byte)(120f * (1f - num416 * 0.5f));
                            EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), underShirtColor, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale * MathHelper.Lerp(0.8f, 1.3f, num416), dir);
                        }
                    }
                }
                if (proj.type == 387)
                {
                    EntitySpriteDraw(TextureAssets.EyeLaserSmall.Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408), new Microsoft.Xna.Framework.Color(255, 255, 255, 0), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                if (proj.type != 525 && proj.type != 960)
                {
                    return;
                }
                int num417 = TryInteractingWithMoneyTrough(proj);
                if (num417 == 0)
                {
                    return;
                }
                int num418 = (projectileColor.R + projectileColor.G + projectileColor.B) / 3;
                if (num418 > 10)
                {
                    int num419 = 94;
                    if (proj.type == 960)
                    {
                        num419 = 244;
                    }
                    Microsoft.Xna.Framework.Color selectionGlowColor = Colors.GetSelectionGlowColor(num417 == 2, num418);
                    EntitySpriteDraw(TextureAssets.Extra[num419].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, y27, TextureAssets.Projectile[proj.type].Width(), num408 - 1), selectionGlowColor, proj.rotation, new Vector2(num138, proj.height / 2 + num136), 1f, dir);
                }
                return;
            }
            if (proj.type == 383 || proj.type == 399)
            {
                Texture2D value111 = TextureAssets.Projectile[proj.type].Value;
                EntitySpriteDraw(value111, proj.Center - screenPosition, null, proj.GetAlpha(projectileColor), proj.rotation, new Vector2(value111.Width, value111.Height) / 2f, proj.scale, dir);
                return;
            }
            if (proj.type == 157 || proj.type == 378)
            {
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + (float)(proj.width / 2), proj.position.Y - screenPosition.Y + (float)(proj.height / 2)), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(TextureAssets.Projectile[proj.type].Width() / 2, TextureAssets.Projectile[proj.type].Height() / 2), proj.scale, dir);
                return;
            }
            if (proj.type == 306)
            {
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + (float)(proj.width / 2), proj.position.Y - screenPosition.Y + (float)(proj.height / 2)), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(TextureAssets.Projectile[proj.type].Width() / 2, TextureAssets.Projectile[proj.type].Height() / 2), proj.scale, dir);
                return;
            }
            if (proj.type == 256)
            {
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + (float)(proj.width / 2), proj.position.Y - screenPosition.Y + (float)(proj.height / 2)), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(TextureAssets.Projectile[proj.type].Width() / 2, TextureAssets.Projectile[proj.type].Height() / 2), proj.scale, dir);
                return;
            }
            if (proj.aiStyle == 27)
            {
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + (float)(proj.width / 2), proj.position.Y - screenPosition.Y + (float)(proj.height / 2)), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(TextureAssets.Projectile[proj.type].Width(), 0f), proj.scale, dir);
                return;
            }
            if (proj.aiStyle == 19)
            {
                DrawProj_Spear(proj, ref projectileColor, ref dir);
                return;
            }
            if (proj.type == 451)
            {
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, proj.Center - screenPosition, null, proj.GetAlpha(projectileColor), proj.rotation, new Vector2(TextureAssets.Projectile[proj.type].Width(), 0f), proj.scale, dir);
                return;
            }
            if (proj.type == 434)
            {
                Vector2 vector112 = new Vector2(proj.ai[0], proj.ai[1]);
                Vector2 v = proj.position - vector112;
                float num420 = (float)Math.Sqrt(v.X * v.X + v.Y * v.Y);
                new Vector2(4f, num420);
                float rotation30 = v.ToRotation() + (float)Math.PI / 2f;
                Vector2 vector113 = Vector2.Lerp(proj.position, vector112, 0.5f);
                Microsoft.Xna.Framework.Color red = Microsoft.Xna.Framework.Color.Red;
                red.A = 0;
                Microsoft.Xna.Framework.Color white6 = Microsoft.Xna.Framework.Color.White;
                red *= proj.localAI[0];
                white6 *= proj.localAI[0];
                float num421 = (float)Math.Sqrt(proj.damage / 50);
                EntitySpriteDraw(TextureAssets.MagicPixel.Value, vector113 - screenPosition, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), red, rotation30, Vector2.One / 2f, new Vector2(2f * num421, num420 + 8f), dir);
                EntitySpriteDraw(TextureAssets.MagicPixel.Value, vector113 - screenPosition, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), red, rotation30, Vector2.One / 2f, new Vector2(4f * num421, num420), dir);
                EntitySpriteDraw(TextureAssets.MagicPixel.Value, vector113 - screenPosition, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), white6, rotation30, Vector2.One / 2f, new Vector2(2f * num421, num420), dir);
                return;
            }
            if (proj.type == 94 && proj.ai[1] > 6f)
            {
                for (int num422 = 0; num422 < 10; num422++)
                {
                    Microsoft.Xna.Framework.Color alpha13 = proj.GetAlpha(projectileColor);
                    float num423 = (float)(9 - num422) / 9f;
                    alpha13.R = (byte)((float)(int)alpha13.R * num423);
                    alpha13.G = (byte)((float)(int)alpha13.G * num423);
                    alpha13.B = (byte)((float)(int)alpha13.B * num423);
                    alpha13.A = (byte)((float)(int)alpha13.A * num423);
                    float num424 = (float)(9 - num422) / 9f;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.oldPos[num422].X - screenPosition.X + num138 + (float)num137, proj.oldPos[num422].Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha13, proj.rotation, new Vector2(num138, proj.height / 2 + num136), num424 * proj.scale, dir);
                }
            }
            if (proj.type == 301)
            {
                for (int num425 = 0; num425 < 10; num425++)
                {
                    Microsoft.Xna.Framework.Color alpha14 = proj.GetAlpha(projectileColor);
                    float num426 = (float)(9 - num425) / 9f;
                    alpha14.R = (byte)((float)(int)alpha14.R * num426);
                    alpha14.G = (byte)((float)(int)alpha14.G * num426);
                    alpha14.B = (byte)((float)(int)alpha14.B * num426);
                    alpha14.A = (byte)((float)(int)alpha14.A * num426);
                    float num427 = (float)(9 - num425) / 9f;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.oldPos[num425].X - screenPosition.X + num138 + (float)num137, proj.oldPos[num425].Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha14, proj.rotation, new Vector2(num138, proj.height / 2 + num136), num427 * proj.scale, dir);
                }
            }
            if (proj.type == 323 && proj.alpha == 0)
            {
                for (int num428 = 1; num428 < 8; num428++)
                {
                    float num429 = proj.velocity.X * (float)num428;
                    float num430 = proj.velocity.Y * (float)num428;
                    Microsoft.Xna.Framework.Color alpha15 = proj.GetAlpha(projectileColor);
                    float num431 = 0f;
                    if (num428 == 1)
                    {
                        num431 = 0.7f;
                    }
                    if (num428 == 2)
                    {
                        num431 = 0.6f;
                    }
                    if (num428 == 3)
                    {
                        num431 = 0.5f;
                    }
                    if (num428 == 4)
                    {
                        num431 = 0.4f;
                    }
                    if (num428 == 5)
                    {
                        num431 = 0.3f;
                    }
                    if (num428 == 6)
                    {
                        num431 = 0.2f;
                    }
                    if (num428 == 7)
                    {
                        num431 = 0.1f;
                    }
                    alpha15.R = (byte)((float)(int)alpha15.R * num431);
                    alpha15.G = (byte)((float)(int)alpha15.G * num431);
                    alpha15.B = (byte)((float)(int)alpha15.B * num431);
                    alpha15.A = (byte)((float)(int)alpha15.A * num431);
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137 - num429, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY - num430), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha15, proj.rotation, new Vector2(num138, proj.height / 2 + num136), num431 + 0.2f, dir);
                }
            }
            if (proj.type == 117 && proj.ai[0] > 3f)
            {
                for (int num432 = 1; num432 < 5; num432++)
                {
                    float num433 = proj.velocity.X * (float)num432;
                    float num434 = proj.velocity.Y * (float)num432;
                    Microsoft.Xna.Framework.Color alpha16 = proj.GetAlpha(projectileColor);
                    float num435 = 0f;
                    if (num432 == 1)
                    {
                        num435 = 0.4f;
                    }
                    if (num432 == 2)
                    {
                        num435 = 0.3f;
                    }
                    if (num432 == 3)
                    {
                        num435 = 0.2f;
                    }
                    if (num432 == 4)
                    {
                        num435 = 0.1f;
                    }
                    alpha16.R = (byte)((float)(int)alpha16.R * num435);
                    alpha16.G = (byte)((float)(int)alpha16.G * num435);
                    alpha16.B = (byte)((float)(int)alpha16.B * num435);
                    alpha16.A = (byte)((float)(int)alpha16.A * num435);
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137 - num433, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY - num434), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha16, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
            }
            if (proj.bobber)
            {
                if (proj.ai[1] > 0f && proj.ai[1] < (float)ItemID.Count && proj.ai[0] == 1f)
                {
                    int num436 = (int)proj.ai[1];
                    Vector2 center5 = proj.Center;
                    float rotation31 = proj.rotation;
                    Vector2 vector114 = center5;
                    float num437 = polePosX - vector114.X;
                    float num438 = polePosY - vector114.Y;
                    rotation31 = (float)Math.Atan2(num438, num437);
                    if (proj.velocity.X > 0f)
                    {
                        dir = SpriteEffects.None;
                        rotation31 = (float)Math.Atan2(num438, num437);
                        rotation31 += 0.785f;
                        if (proj.ai[1] == 2342f)
                        {
                            rotation31 -= 0.785f;
                        }
                    }
                    else
                    {
                        dir = SpriteEffects.FlipHorizontally;
                        rotation31 = (float)Math.Atan2(0f - num438, 0f - num437);
                        rotation31 -= 0.785f;
                        if (proj.ai[1] == 2342f)
                        {
                            rotation31 += 0.785f;
                        }
                    }
                    instance.LoadItem(num436);
                    Texture2D value112 = TextureAssets.Item[num436].Value;
                    Microsoft.Xna.Framework.Rectangle value113 = value112.Frame();
                    if (ItemID.Sets.IsFood[num436] && itemAnimations[num436] != null)
                    {
                        value113 = itemAnimations[num436].GetFrame(value112, 0);
                    }
                    EntitySpriteDraw(value112, new Vector2(center5.X - screenPosition.X, center5.Y - screenPosition.Y), value113, projectileColor, rotation31, new Vector2(value113.Width / 2, value113.Height / 2), proj.scale, dir);
                }
                else if (proj.ai[0] <= 1f)
                {
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    if (proj.glowMask != -1)
                    {
                        Texture2D value114 = TextureAssets.GlowMask[proj.glowMask].Value;
                        Microsoft.Xna.Framework.Color newColor5 = Microsoft.Xna.Framework.Color.White;
                        if (proj.type == 993)
                        {
                            newColor5 = new Microsoft.Xna.Framework.Color(DiscoR, DiscoG, DiscoB);
                        }
                        EntitySpriteDraw(value114, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, value114.Width, value114.Height), proj.GetAlpha(newColor5), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    }
                }
            }
            else
            {
                if (proj.ownerHitCheck && Main.player[proj.owner].gravDir == -1f)
                {
                    if (Main.player[proj.owner].direction == 1)
                    {
                        dir = SpriteEffects.FlipHorizontally;
                    }
                    else if (Main.player[proj.owner].direction == -1)
                    {
                        dir = SpriteEffects.None;
                    }
                }
                EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                if (proj.glowMask != -1)
                {
                    EntitySpriteDraw(TextureAssets.GlowMask[proj.glowMask].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), new Microsoft.Xna.Framework.Color(250, 250, 250, proj.alpha), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                if (proj.type == 473)
                {
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), new Microsoft.Xna.Framework.Color(255, 255, 0, 0), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
                if (proj.type >= 511 && proj.type <= 513)
                {
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), proj.GetAlpha(projectileColor) * 0.25f, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale * (1f + proj.Opacity * 1.75f), dir);
                }
                if (proj.type == 312)
                {
                    ulong seed3 = TileFrameSeed;
                    for (int num439 = 0; num439 < 4; num439++)
                    {
                        Vector2 vector115 = new Vector2(Utils.RandomInt(ref seed3, -2, 3), Utils.RandomInt(ref seed3, -2, 3));
                        EntitySpriteDraw(TextureAssets.GlowMask[proj.glowMask].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY) + vector115, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), new Microsoft.Xna.Framework.Color(255, 255, 255, 255) * 0.2f, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                    }
                }
            }
            if (proj.type == 106)
            {
                Texture2D value115 = TextureAssets.LightDisc.Value;
                Vector2 position26 = new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2));
                Microsoft.Xna.Framework.Rectangle value116 = value115.Frame();
                EntitySpriteDraw(value115, position26, value116, new Microsoft.Xna.Framework.Color(200, 200, 200, 0), proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
            }
            if (proj.type >= 326 && proj.type <= 328)
            {
                ulong seed4 = TileFrameSeed;
                for (int num440 = 0; num440 < 4; num440++)
                {
                    Vector2 vector116 = new Vector2(Utils.RandomInt(ref seed4, -2, 3), Utils.RandomInt(ref seed4, -2, 3));
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137, proj.position.Y - screenPosition.Y + (float)(proj.height / 2)) + vector116 - proj.velocity * 0.25f * num440, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), new Microsoft.Xna.Framework.Color(120, 120, 120, 60) * 1f, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale - (float)num440 * 0.2f, dir);
                }
            }
            if (proj.type == 554 || proj.type == 603)
            {
                for (int num441 = 1; num441 < 5; num441++)
                {
                    float num442 = proj.velocity.X * (float)num441 * 0.5f;
                    float num443 = proj.velocity.Y * (float)num441 * 0.5f;
                    Microsoft.Xna.Framework.Color alpha17 = proj.GetAlpha(projectileColor);
                    float num444 = 0f;
                    if (num441 == 1)
                    {
                        num444 = 0.4f;
                    }
                    if (num441 == 2)
                    {
                        num444 = 0.3f;
                    }
                    if (num441 == 3)
                    {
                        num444 = 0.2f;
                    }
                    if (num441 == 4)
                    {
                        num444 = 0.1f;
                    }
                    alpha17.R = (byte)((float)(int)alpha17.R * num444);
                    alpha17.G = (byte)((float)(int)alpha17.G * num444);
                    alpha17.B = (byte)((float)(int)alpha17.B * num444);
                    alpha17.A = (byte)((float)(int)alpha17.A * num444);
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137 - num442, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY - num443), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha17, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
            }
            else if (proj.type == 604)
            {
                int num445 = (int)proj.ai[1] + 1;
                if (num445 > 7)
                {
                    num445 = 7;
                }
                for (int num446 = 1; num446 < num445; num446++)
                {
                    float num447 = proj.velocity.X * (float)num446 * 1.5f;
                    float num448 = proj.velocity.Y * (float)num446 * 1.5f;
                    Microsoft.Xna.Framework.Color alpha18 = proj.GetAlpha(projectileColor);
                    float num449 = 0f;
                    if (num446 == 1)
                    {
                        num449 = 0.4f;
                    }
                    if (num446 == 2)
                    {
                        num449 = 0.3f;
                    }
                    if (num446 == 3)
                    {
                        num449 = 0.2f;
                    }
                    if (num446 == 4)
                    {
                        num449 = 0.1f;
                    }
                    num449 = 0.4f - (float)num446 * 0.06f;
                    num449 *= 1f - (float)proj.alpha / 255f;
                    alpha18.R = (byte)((float)(int)alpha18.R * num449);
                    alpha18.G = (byte)((float)(int)alpha18.G * num449);
                    alpha18.B = (byte)((float)(int)alpha18.B * num449);
                    alpha18.A = (byte)((float)(int)alpha18.A * num449 / 2f);
                    float scale15 = proj.scale;
                    scale15 -= (float)num446 * 0.1f;
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137 - num447, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY - num448), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha18, proj.rotation, new Vector2(num138, proj.height / 2 + num136), scale15, dir);
                }
            }
            else
            {
                if (proj.type != 553)
                {
                    return;
                }
                for (int num450 = 1; num450 < 5; num450++)
                {
                    float num451 = proj.velocity.X * (float)num450 * 0.4f;
                    float num452 = proj.velocity.Y * (float)num450 * 0.4f;
                    Microsoft.Xna.Framework.Color alpha19 = proj.GetAlpha(projectileColor);
                    float num453 = 0f;
                    if (num450 == 1)
                    {
                        num453 = 0.4f;
                    }
                    if (num450 == 2)
                    {
                        num453 = 0.3f;
                    }
                    if (num450 == 3)
                    {
                        num453 = 0.2f;
                    }
                    if (num450 == 4)
                    {
                        num453 = 0.1f;
                    }
                    alpha19.R = (byte)((float)(int)alpha19.R * num453);
                    alpha19.G = (byte)((float)(int)alpha19.G * num453);
                    alpha19.B = (byte)((float)(int)alpha19.B * num453);
                    alpha19.A = (byte)((float)(int)alpha19.A * num453);
                    EntitySpriteDraw(TextureAssets.Projectile[proj.type].Value, new Vector2(proj.position.X - screenPosition.X + num138 + (float)num137 - num451, proj.position.Y - screenPosition.Y + (float)(proj.height / 2) + proj.gfxOffY - num452), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Projectile[proj.type].Width(), TextureAssets.Projectile[proj.type].Height()), alpha19, proj.rotation, new Vector2(num138, proj.height / 2 + num136), proj.scale, dir);
                }
            }
        }
    }
 
    private static void DrawProj_Flamethrower(Projectile proj)
    {
        bool flag = proj.ai[0] == 1f;
        float num = 60f;
        float num2 = 12f;
        float fromMax = num + num2;
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Color transparent = Microsoft.Xna.Framework.Color.Transparent;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(255, 80, 20, 200);
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(255, 255, 20, 70);
        Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.Lerp(new Microsoft.Xna.Framework.Color(255, 80, 20, 100), color2, 0.25f);
        Microsoft.Xna.Framework.Color color4 = new Microsoft.Xna.Framework.Color(80, 80, 80, 100);
        float num3 = 0.35f;
        float num4 = 0.7f;
        float num5 = 0.85f;
        float num6 = ((proj.localAI[0] > num - 10f) ? 0.175f : 0.2f);
        if (flag)
        {
            color = new Microsoft.Xna.Framework.Color(95, 120, 255, 200);
            color2 = new Microsoft.Xna.Framework.Color(50, 180, 255, 70);
            color3 = new Microsoft.Xna.Framework.Color(95, 160, 255, 100);
            color4 = new Microsoft.Xna.Framework.Color(33, 125, 202, 100);
        }
        int num7 = 3;
        int num8 = 2;
        int verticalFrames = 7;
        float num9 = Utils.Remap(proj.localAI[0], num, fromMax, 1f, 0f);
        float num10 = Math.Min(proj.localAI[0], 20f);
        float num11 = Utils.Remap(proj.localAI[0], 0f, fromMax, 0f, 1f);
        float num12 = Utils.Remap(num11, 0.2f, 0.5f, 0.25f, 1f);
        Microsoft.Xna.Framework.Rectangle rectangle = ((!flag) ? value.Frame(1, verticalFrames, 0, 3) : value.Frame(1, verticalFrames, 0, (int)Utils.Remap(num11, 0.5f, 1f, 3f, 5f)));
        if (!(num11 < 1f))
        {
            return;
        }
        for (int i = 0; i < 2; i++)
        {
            for (float num13 = 1f; num13 >= 0f; num13 -= num6)
            {
                transparent = ((num11 < 0.1f) ? Microsoft.Xna.Framework.Color.Lerp(Microsoft.Xna.Framework.Color.Transparent, color, Utils.GetLerpValue(0f, 0.1f, num11, clamped: true)) : ((num11 < 0.2f) ? Microsoft.Xna.Framework.Color.Lerp(color, color2, Utils.GetLerpValue(0.1f, 0.2f, num11, clamped: true)) : ((num11 < num3) ? color2 : ((num11 < num4) ? Microsoft.Xna.Framework.Color.Lerp(color2, color3, Utils.GetLerpValue(num3, num4, num11, clamped: true)) : ((num11 < num5) ? Microsoft.Xna.Framework.Color.Lerp(color3, color4, Utils.GetLerpValue(num4, num5, num11, clamped: true)) : ((!(num11 < 1f)) ? Microsoft.Xna.Framework.Color.Transparent : Microsoft.Xna.Framework.Color.Lerp(color4, Microsoft.Xna.Framework.Color.Transparent, Utils.GetLerpValue(num5, 1f, num11, clamped: true))))))));
                float num14 = (1f - num13) * Utils.Remap(num11, 0f, 0.2f, 0f, 1f);
                Vector2 vector = proj.Center - screenPosition + proj.velocity * (0f - num10) * num13;
                Microsoft.Xna.Framework.Color color5 = transparent * num14;
                Microsoft.Xna.Framework.Color color6 = color5;
                if (!flag)
                {
                    color6.G /= 2;
                    color6.B /= 2;
                    color6.A = (byte)Math.Min((float)(int)color5.A + 80f * num14, 255f);
                    Utils.Remap(proj.localAI[0], 20f, fromMax, 0f, 1f);
                }
                float num15 = 1f / num6 * (num13 + 1f);
                float num16 = proj.rotation + num13 * ((float)Math.PI / 2f) + GlobalTimeWrappedHourly * num15 * 2f;
                float num17 = proj.rotation - num13 * ((float)Math.PI / 2f) - GlobalTimeWrappedHourly * num15 * 2f;
                switch (i)
                {
                case 0:
                    EntitySpriteDraw(value, vector + proj.velocity * (0f - num10) * num6 * 0.5f, rectangle, color6 * num9 * 0.25f, num16 + (float)Math.PI / 4f, rectangle.Size() / 2f, num12, SpriteEffects.None);
                    EntitySpriteDraw(value, vector, rectangle, color6 * num9, num17, rectangle.Size() / 2f, num12, SpriteEffects.None);
                    break;
                case 1:
                    if (!flag)
                    {
                        EntitySpriteDraw(value, vector + proj.velocity * (0f - num10) * num6 * 0.2f, rectangle, color5 * num9 * 0.25f, num16 + (float)Math.PI / 2f, rectangle.Size() / 2f, num12 * 0.75f, SpriteEffects.None);
                        EntitySpriteDraw(value, vector, rectangle, color5 * num9, num17 + (float)Math.PI / 2f, rectangle.Size() / 2f, num12 * 0.75f, SpriteEffects.None);
                    }
                    break;
                }
            }
        }
    }
 
    private static void DrawProj_Spear(Projectile proj, ref Microsoft.Xna.Framework.Color projectileColor, ref SpriteEffects dir)
    {
        dir = SpriteEffects.None;
        float num = (float)Math.Atan2(proj.velocity.Y, proj.velocity.X) + 2.355f;
        Asset<Texture2D> val = TextureAssets.Projectile[proj.type];
        Player player = Main.player[proj.owner];
        Microsoft.Xna.Framework.Rectangle value = val.Frame();
        Microsoft.Xna.Framework.Rectangle rect = proj.getRect();
        Vector2 vector = Vector2.Zero;
        if (player.direction > 0)
        {
            dir = SpriteEffects.FlipHorizontally;
            vector.X = val.Width();
            num -= (float)Math.PI / 2f;
        }
        if (player.gravDir == -1f)
        {
            if (proj.direction == 1)
            {
                dir = SpriteEffects.FlipHorizontally | SpriteEffects.FlipVertically;
                vector = new Vector2(val.Width(), val.Height());
                num -= (float)Math.PI / 2f;
            }
            else if (proj.direction == -1)
            {
                dir = SpriteEffects.FlipVertically;
                vector = new Vector2(0f, val.Height());
                num += (float)Math.PI / 2f;
            }
        }
        Vector2.Lerp(vector, value.Center.ToVector2(), 0.25f);
        float num2 = 0f;
        Vector2 vector2 = proj.Center + new Vector2(0f, proj.gfxOffY);
        if (proj.AI_019_Spears_GetExtensionHitbox(out var extensionBox))
        {
            Vector2 value2 = player.RotatedRelativePoint(player.MountedCenter, reverseRotation: false, addGfxOffY: false);
            float num3 = extensionBox.Size().Length() / proj.Hitbox.Size().Length();
            _ = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 1f;
            float num4 = Utils.Remap(player.itemAnimation, player.itemAnimationMax, (float)player.itemAnimationMax / 3f, 0f, 1f);
            float num5 = Utils.Remap(num4, 0f, 0.3f, 0f, 1f) * Utils.Remap(num4, 0.3f, 1f, 1f, 0f);
            num5 = 1f - (1f - num5) * (1f - num5);
            Vector2 vector3 = extensionBox.Center.ToVector2() + new Vector2(0f, proj.gfxOffY);
            Vector2.Lerp(value2, vector3, 1.1f);
            Texture2D value3 = TextureAssets.Extra[98].Value;
            Vector2 origin = value3.Size() / 2f;
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.5f;
            switch (proj.type)
            {
            case 105:
                color = new Microsoft.Xna.Framework.Color(255, 220, 80, 0);
                break;
            case 46:
                color = new Microsoft.Xna.Framework.Color(180, 80, 255, 0);
                break;
            case 342:
                color = new Microsoft.Xna.Framework.Color(80, 140, 255, 0);
                break;
            case 153:
                color = new Microsoft.Xna.Framework.Color(255, 50, 30, 15);
                break;
            }
            float num6 = num - (float)Math.PI / 4f * (float)proj.spriteDirection;
            if (player.gravDir < 0f)
            {
                num6 -= (float)Math.PI / 2f * (float)proj.spriteDirection;
            }
            EntitySpriteDraw(value3, Vector2.Lerp(vector3, vector2, 0.5f) - screenPosition, null, color * num5, num6, origin, new Vector2(num5 * num3, num3) * proj.scale * num3, dir);
            EntitySpriteDraw(value3, Vector2.Lerp(vector3, vector2, 1f) - screenPosition, null, color * num5, num6, origin, new Vector2(num5 * num3, num3 * 1.5f) * proj.scale * num3, dir);
            EntitySpriteDraw(value3, Vector2.Lerp(value2, vector2, num4 * 1.5f - 0.5f) - screenPosition + new Vector2(0f, 2f), null, color * num5, num6, origin, new Vector2(num5 * num3 * 1f * num5, num3 * 2f * num5) * proj.scale * num3, dir);
            for (float num7 = 0.4f; num7 <= 1f; num7 += 0.1f)
            {
                Vector2 vector4 = Vector2.Lerp(value2, vector3, num7 + 0.2f);
                EntitySpriteDraw(value3, vector4 - screenPosition + new Vector2(0f, 2f), null, color * num5 * 0.75f * num7, num6, origin, new Vector2(num5 * num3 * 1f * num5, num3 * 2f * num5) * proj.scale * num3, dir);
            }
            extensionBox.Offset((int)(0f - screenPosition.X), (int)(0f - screenPosition.Y));
        }
        EntitySpriteDraw(val.Value, vector2 - screenPosition, value, proj.GetAlpha(projectileColor), num, vector, proj.scale, dir);
        rect.Offset((int)(0f - screenPosition.X), (int)(0f - screenPosition.Y));
        spriteBatch.Draw(TextureAssets.MagicPixel.Value, rect, Microsoft.Xna.Framework.Color.White * num2);
    }
 
    private static void DrawPrettyStarSparkle(float opacity, SpriteEffects dir, Vector2 drawpos, Microsoft.Xna.Framework.Color drawColor, Microsoft.Xna.Framework.Color shineColor, float flareCounter, float fadeInStart, float fadeInEnd, float fadeOutStart, float fadeOutEnd, float rotation, Vector2 scale, Vector2 fatness)
    {
        Texture2D value = TextureAssets.Extra[98].Value;
        Microsoft.Xna.Framework.Color color = shineColor * opacity * 0.5f;
        color.A = 0;
        Vector2 origin = value.Size() / 2f;
        Microsoft.Xna.Framework.Color color2 = drawColor * 0.5f;
        float num = Utils.GetLerpValue(fadeInStart, fadeInEnd, flareCounter, clamped: true) * Utils.GetLerpValue(fadeOutEnd, fadeOutStart, flareCounter, clamped: true);
        Vector2 vector = new Vector2(fatness.X * 0.5f, scale.X) * num;
        Vector2 vector2 = new Vector2(fatness.Y * 0.5f, scale.Y) * num;
        color *= num;
        color2 *= num;
        EntitySpriteDraw(value, drawpos, null, color, (float)Math.PI / 2f + rotation, origin, vector, dir);
        EntitySpriteDraw(value, drawpos, null, color, 0f + rotation, origin, vector2, dir);
        EntitySpriteDraw(value, drawpos, null, color2, (float)Math.PI / 2f + rotation, origin, vector * 0.6f, dir);
        EntitySpriteDraw(value, drawpos, null, color2, 0f + rotation, origin, vector2 * 0.6f, dir);
    }
 
    private static void DrawProj_FlailChains(Projectile proj, Vector2 mountedCenter)
    {
        Player player = Main.player[proj.owner];
        Vector2 playerArmPosition = GetPlayerArmPosition(proj);
        playerArmPosition -= Vector2.UnitY * player.gfxOffY;
        Asset<Texture2D> val = null;
        Microsoft.Xna.Framework.Rectangle? sourceRectangle = null;
        float num = 0f;
        switch (proj.type)
        {
        default:
            val = TextureAssets.Chain3;
            break;
        case 25:
            val = TextureAssets.Chain2;
            break;
        case 35:
            val = TextureAssets.Chain6;
            break;
        case 63:
            val = TextureAssets.Chain7;
            break;
        case 154:
            val = TextureAssets.Chain13;
            break;
        case 247:
            val = TextureAssets.Chain19;
            break;
        case 757:
            val = TextureAssets.Extra[99];
            sourceRectangle = val.Frame(1, 6);
            num = -2f;
            break;
        case 947:
            val = TextureAssets.Chain41;
            break;
        case 948:
            val = TextureAssets.Chain43;
            break;
        }
        Vector2 origin = (sourceRectangle.HasValue ? (sourceRectangle.Value.Size() / 2f) : (val.Size() / 2f));
        Vector2 center = proj.Center;
        Vector2 v = playerArmPosition.MoveTowards(center, 4f) - center;
        Vector2 vector = v.SafeNormalize(Vector2.Zero);
        float num2 = (float)(sourceRectangle.HasValue ? sourceRectangle.Value.Height : val.Height()) + num;
        float rotation = vector.ToRotation() + (float)Math.PI / 2f;
        int num3 = 0;
        float num4 = v.Length() + num2 / 2f;
        int num5 = 0;
        while (num4 > 0f)
        {
            Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)center.X / 16, (int)(center.Y / 16f));
            switch (proj.type)
            {
            case 757:
                sourceRectangle = val.Frame(1, 6, 0, num3 % 6);
                break;
            case 948:
                if (num5 >= 6)
                {
                    val = (val = TextureAssets.Chain41);
                }
                else if (num5 >= 4)
                {
                    val = (val = TextureAssets.Chain42);
                    byte b = 140;
                    if (color.R < b)
                    {
                        color.R = b;
                    }
                    if (color.G < b)
                    {
                        color.G = b;
                    }
                    if (color.B < b)
                    {
                        color.B = b;
                    }
                }
                else
                {
                    color = Microsoft.Xna.Framework.Color.White;
                }
                num5++;
                break;
            }
            spriteBatch.Draw(val.Value, center - screenPosition, sourceRectangle, color, rotation, origin, 1f, SpriteEffects.None, 0f);
            center += vector * num2;
            num3++;
            num4 -= num2;
        }
    }
 
    private static void DrawProj_FlailChains_Old(Projectile proj, Vector2 mountedCenter)
    {
        Vector2 vector = new Vector2(proj.position.X + (float)proj.width * 0.5f, proj.position.Y + (float)proj.height * 0.5f);
        float num = mountedCenter.X - vector.X;
        float num2 = mountedCenter.Y - vector.Y;
        float rotation = (float)Math.Atan2(num2, num) - 1.57f;
        if (proj.alpha == 0)
        {
            int num3 = -1;
            if (proj.position.X + (float)(proj.width / 2) < mountedCenter.X)
            {
                num3 = 1;
            }
            if (player[proj.owner].direction == 1)
            {
                player[proj.owner].itemRotation = (float)Math.Atan2(num2 * (float)num3, num * (float)num3);
            }
            else
            {
                player[proj.owner].itemRotation = (float)Math.Atan2(num2 * (float)num3, num * (float)num3);
            }
        }
        bool flag = true;
        int num4 = 0;
        int num5 = 25;
        if (proj.type == 757)
        {
            num5 = 12;
        }
        while (flag)
        {
            float num6 = (float)Math.Sqrt(num * num + num2 * num2);
            if (num6 < (float)num5)
            {
                flag = false;
            }
            else if (float.IsNaN(num6))
            {
                flag = false;
            }
            else
            {
                num6 = ((proj.type == 154 || proj.type == 247) ? (18f / num6) : ((proj.type != 757) ? (12f / num6) : (16f / num6)));
                num *= num6;
                num2 *= num6;
                vector.X += num;
                vector.Y += num2;
                num = mountedCenter.X - vector.X;
                num2 = mountedCenter.Y - vector.Y;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f));
                if (proj.type == 25)
                {
                    EntitySpriteDraw(TextureAssets.Chain2.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain2.Width(), TextureAssets.Chain2.Height()), color, rotation, new Vector2((float)TextureAssets.Chain2.Width() * 0.5f, (float)TextureAssets.Chain2.Height() * 0.5f), 1f, SpriteEffects.None);
                }
                else if (proj.type == 35)
                {
                    EntitySpriteDraw(TextureAssets.Chain6.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain6.Width(), TextureAssets.Chain6.Height()), color, rotation, new Vector2((float)TextureAssets.Chain6.Width() * 0.5f, (float)TextureAssets.Chain6.Height() * 0.5f), 1f, SpriteEffects.None);
                }
                else if (proj.type == 757)
                {
                    Texture2D value = TextureAssets.Extra[99].Value;
                    Microsoft.Xna.Framework.Rectangle r = value.Frame(1, 6, 0, num4 % 6);
                    EntitySpriteDraw(value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), value.Frame(1, 6, 0, num4 % 6), color, rotation, r.Size() / 2f, 1f, SpriteEffects.None);
                }
                else if (proj.type == 247)
                {
                    EntitySpriteDraw(TextureAssets.Chain19.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain19.Width(), TextureAssets.Chain19.Height()), color, rotation, new Vector2((float)TextureAssets.Chain19.Width() * 0.5f, (float)TextureAssets.Chain19.Height() * 0.5f), 1f, SpriteEffects.None);
                }
                else if (proj.type == 63)
                {
                    EntitySpriteDraw(TextureAssets.Chain7.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain7.Width(), TextureAssets.Chain7.Height()), color, rotation, new Vector2((float)TextureAssets.Chain7.Width() * 0.5f, (float)TextureAssets.Chain7.Height() * 0.5f), 1f, SpriteEffects.None);
                }
                else if (proj.type == 154)
                {
                    EntitySpriteDraw(TextureAssets.Chain13.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain13.Width(), TextureAssets.Chain13.Height()), color, rotation, new Vector2((float)TextureAssets.Chain13.Width() * 0.5f, (float)TextureAssets.Chain13.Height() * 0.5f), 1f, SpriteEffects.None);
                }
                else
                {
                    EntitySpriteDraw(TextureAssets.Chain3.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain3.Width(), TextureAssets.Chain3.Height()), color, rotation, new Vector2((float)TextureAssets.Chain3.Width() * 0.5f, (float)TextureAssets.Chain3.Height() * 0.5f), 1f, SpriteEffects.None);
                }
            }
            num4++;
        }
    }
 
    private static Microsoft.Xna.Framework.Color TryApplyingPlayerStringColor(int playerStringColor, Microsoft.Xna.Framework.Color stringColor)
    {
        if (playerStringColor > 0)
        {
            stringColor = WorldGen.paintColor(playerStringColor);
            if (stringColor.R < 75)
            {
                stringColor.R = 75;
            }
            if (stringColor.G < 75)
            {
                stringColor.G = 75;
            }
            if (stringColor.B < 75)
            {
                stringColor.B = 75;
            }
            switch (playerStringColor)
            {
            case 13:
                stringColor = new Microsoft.Xna.Framework.Color(20, 20, 20);
                break;
            case 0:
            case 14:
                stringColor = new Microsoft.Xna.Framework.Color(200, 200, 200);
                break;
            case 28:
                stringColor = new Microsoft.Xna.Framework.Color(163, 116, 91);
                break;
            case 27:
                stringColor = new Microsoft.Xna.Framework.Color(DiscoR, DiscoG, DiscoB);
                break;
            }
            stringColor.A = (byte)((float)(int)stringColor.A * 0.4f);
        }
        return stringColor;
    }
 
    private static void DrawProj_FishingLine(Projectile proj, ref float polePosX, ref float polePosY, Vector2 mountedCenter)
    {
        Player player = Main.player[proj.owner];
        polePosX = mountedCenter.X;
        polePosY = mountedCenter.Y;
        polePosY += player.gfxOffY;
        if (player.mount.Active && player.mount.Type == 52)
        {
            polePosX -= player.direction * 14;
            polePosY -= -10f;
        }
        int type = player.inventory[player.selectedItem].type;
        Microsoft.Xna.Framework.Color stringColor = new Microsoft.Xna.Framework.Color(200, 200, 200, 100);
        if (type == 2294)
        {
            stringColor = new Microsoft.Xna.Framework.Color(100, 180, 230, 100);
        }
        if (type == 2295)
        {
            stringColor = new Microsoft.Xna.Framework.Color(250, 90, 70, 100);
        }
        if (type == 2293)
        {
            stringColor = new Microsoft.Xna.Framework.Color(203, 190, 210, 100);
        }
        if (type == 2421)
        {
            stringColor = new Microsoft.Xna.Framework.Color(183, 77, 112, 100);
        }
        if (type == 2422)
        {
            stringColor = new Microsoft.Xna.Framework.Color(255, 226, 116, 100);
        }
        if (type == 4325)
        {
            stringColor = new Microsoft.Xna.Framework.Color(200, 100, 100, 100);
        }
        if (type == 4442)
        {
            stringColor = new Microsoft.Xna.Framework.Color(100, 100, 200, 100);
        }
        stringColor = TryApplyingPlayerStringColor(Main.player[proj.owner].stringColor, stringColor);
        float gravDir = Main.player[proj.owner].gravDir;
        switch (type)
        {
        case 2289:
            polePosX += 43 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 36f * gravDir;
            break;
        case 2291:
            polePosX += 43 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 34f * gravDir;
            break;
        case 2292:
            polePosX += 46 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 34f * gravDir;
            break;
        case 2293:
            polePosX += 43 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 34f * gravDir;
            break;
        case 2294:
            polePosX += 43 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 30f * gravDir;
            break;
        case 2295:
            polePosX += 43 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 30f * gravDir;
            break;
        case 2296:
            polePosX += 43 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 30f * gravDir;
            break;
        case 2421:
            polePosX += 47 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 36f * gravDir;
            break;
        case 2422:
            polePosX += 47 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 32f * gravDir;
            break;
        case 4325:
            polePosX += 44 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 32f * gravDir;
            break;
        case 4442:
            polePosX += 44 * Main.player[proj.owner].direction;
            if (Main.player[proj.owner].direction < 0)
            {
                polePosX -= 13f;
            }
            polePosY -= 32f * gravDir;
            break;
        }
        if (gravDir == -1f)
        {
            polePosY -= 12f;
        }
        Vector2 vector = new Vector2(polePosX, polePosY);
        vector = Main.player[proj.owner].RotatedRelativePoint(vector + new Vector2(8f)) - new Vector2(8f);
        float num = proj.position.X + (float)proj.width * 0.5f - vector.X;
        float num2 = proj.position.Y + (float)proj.height * 0.5f - vector.Y;
        Math.Sqrt(num * num + num2 * num2);
        float num3 = (float)Math.Atan2(num2, num) - 1.57f;
        bool flag = true;
        if (num == 0f && num2 == 0f)
        {
            flag = false;
        }
        else
        {
            float num4 = (float)Math.Sqrt(num * num + num2 * num2);
            num4 = 12f / num4;
            num *= num4;
            num2 *= num4;
            vector.X -= num;
            vector.Y -= num2;
            num = proj.position.X + (float)proj.width * 0.5f - vector.X;
            num2 = proj.position.Y + (float)proj.height * 0.5f - vector.Y;
        }
        while (flag)
        {
            float num5 = 12f;
            float num6 = (float)Math.Sqrt(num * num + num2 * num2);
            float num7 = num6;
            if (float.IsNaN(num6) || float.IsNaN(num7))
            {
                flag = false;
                continue;
            }
            if (num6 < 20f)
            {
                num5 = num6 - 8f;
                flag = false;
            }
            num6 = 12f / num6;
            num *= num6;
            num2 *= num6;
            vector.X += num;
            vector.Y += num2;
            num = proj.position.X + (float)proj.width * 0.5f - vector.X;
            num2 = proj.position.Y + (float)proj.height * 0.1f - vector.Y;
            if (num7 > 12f)
            {
                float num8 = 0.3f;
                float num9 = Math.Abs(proj.velocity.X) + Math.Abs(proj.velocity.Y);
                if (num9 > 16f)
                {
                    num9 = 16f;
                }
                num9 = 1f - num9 / 16f;
                num8 *= num9;
                num9 = num7 / 80f;
                if (num9 > 1f)
                {
                    num9 = 1f;
                }
                num8 *= num9;
                if (num8 < 0f)
                {
                    num8 = 0f;
                }
                num9 = 1f - proj.localAI[0] / 100f;
                num8 *= num9;
                if (num2 > 0f)
                {
                    num2 *= 1f + num8;
                    num *= 1f - num8;
                }
                else
                {
                    num9 = Math.Abs(proj.velocity.X) / 3f;
                    if (num9 > 1f)
                    {
                        num9 = 1f;
                    }
                    num9 -= 0.5f;
                    num8 *= num9;
                    if (num8 > 0f)
                    {
                        num8 *= 2f;
                    }
                    num2 *= 1f + num8;
                    num *= 1f - num8;
                }
            }
            num3 = (float)Math.Atan2(num2, num) - 1.57f;
            Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f), stringColor);
            EntitySpriteDraw(TextureAssets.FishingLine.Value, new Vector2(vector.X - screenPosition.X + (float)TextureAssets.FishingLine.Width() * 0.5f, vector.Y - screenPosition.Y + (float)TextureAssets.FishingLine.Height() * 0.5f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.FishingLine.Width(), (int)num5), color, num3, new Vector2((float)TextureAssets.FishingLine.Width() * 0.5f, 0f), 1f, SpriteEffects.None);
        }
    }
 
    private void DrawProj_StardustGuardianPunching(Projectile proj)
    {
        if (!gamePaused)
        {
            int num = 6;
            Texture2D value = TextureAssets.Extra[46].Value;
            int num2 = 20;
            Vector2 vector = proj.Center - proj.rotation.ToRotationVector2() * num2 * proj.spriteDirection;
            for (int i = 0; i < num; i++)
            {
                float num3 = rand.NextFloat();
                float num4 = Utils.GetLerpValue(0f, 0.3f, num3, clamped: true) * Utils.GetLerpValue(1f, 0.5f, num3, clamped: true);
                float amount = Utils.GetLerpValue(0f, 0.3f, num3, clamped: true) * Utils.GetLerpValue(1f, 0.5f, num3, clamped: true);
                float num5 = MathHelper.Lerp(0.6f, 1f, amount);
                Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(255, 255, 255, 127);
                color *= num4 * 0.5f;
                Vector2 origin = value.Size() / 2f;
                Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.White * num4;
                color2.A /= 2;
                Microsoft.Xna.Framework.Color color3 = color2 * 0.5f;
                float num6 = 1f;
                float num7 = 1f + rand.NextFloat() * 0.5f;
                float num8 = rand.NextFloatDirection();
                Vector2 vector2 = new Vector2(0.8f) * num7 * num6 * num5;
                float num9 = 20f + MathHelper.Lerp(0f, 20f, num3) + num7 * 16f;
                float num10 = proj.rotation + ((proj.direction == 1) ? 0f : ((float)Math.PI)) + num8 * ((float)Math.PI * 2f) * 0.04f;
                float rotation = num10 + (float)Math.PI / 2f;
                Vector2 position = vector + num10.ToRotationVector2() * num9 + rand.NextVector2Circular(20f, 20f) - screenPosition;
                color *= num6;
                color3 *= num6;
                SpriteEffects effects = SpriteEffects.None;
                spriteBatch.Draw(value, position, null, color, rotation, origin, vector2, effects, 0f);
                spriteBatch.Draw(value, position, null, color3, rotation, origin, vector2 * 0.8f, effects, 0f);
            }
        }
    }
 
    private void DrawProj_PiercingStarlight(Projectile proj)
    {
        float num = proj.ai[1];
        if (num == 0f)
        {
            num = 1f;
        }
        int num2 = (int)Math.Ceiling(3f * num);
        LoadProjectile(proj.type);
        LoadItem(4923);
        int num3 = 2;
        Vector2 vector = proj.Center - proj.rotation.ToRotationVector2() * num3;
        for (int i = 0; i < 1; i++)
        {
            float num4 = rand.NextFloat();
            float num5 = Utils.GetLerpValue(0f, 0.3f, num4, clamped: true) * Utils.GetLerpValue(1f, 0.5f, num4, clamped: true);
            Microsoft.Xna.Framework.Color color = proj.GetAlpha(Lighting.GetColor(proj.Center.ToTileCoordinates())) * num5;
            Texture2D value = TextureAssets.Item[4923].Value;
            Vector2 origin = value.Size() / 2f;
            float num6 = rand.NextFloatDirection();
            float num7 = 8f + MathHelper.Lerp(0f, 20f, num4) + rand.NextFloat() * 6f;
            float num8 = proj.rotation + num6 * ((float)Math.PI * 2f) * 0.04f;
            float num9 = num8 + (float)Math.PI / 4f;
            Vector2 position = vector + num8.ToRotationVector2() * num7 + rand.NextVector2Circular(8f, 8f) - screenPosition;
            SpriteEffects spriteEffects = SpriteEffects.None;
            if (proj.rotation < -(float)Math.PI / 2f || proj.rotation > (float)Math.PI / 2f)
            {
                num9 += (float)Math.PI / 2f;
                spriteEffects |= SpriteEffects.FlipHorizontally;
            }
            spriteBatch.Draw(value, position, null, color, num9, origin, 1f, spriteEffects, 0f);
        }
        for (int j = 0; j < num2; j++)
        {
            float num10 = rand.NextFloat();
            float num11 = Utils.GetLerpValue(0f, 0.3f, num10, clamped: true) * Utils.GetLerpValue(1f, 0.5f, num10, clamped: true);
            float amount = Utils.GetLerpValue(0f, 0.3f, num10, clamped: true) * Utils.GetLerpValue(1f, 0.5f, num10, clamped: true);
            float num12 = MathHelper.Lerp(0.6f, 1f, amount);
            Microsoft.Xna.Framework.Color fairyQueenWeaponsColor = proj.GetFairyQueenWeaponsColor(0.25f, 0f, (rand.NextFloat() * 0.33f + GlobalTimeWrappedHourly) % 1f);
            Texture2D value2 = TextureAssets.Projectile[proj.type].Value;
            Microsoft.Xna.Framework.Color color2 = fairyQueenWeaponsColor;
            color2 *= num11 * 0.5f;
            Vector2 origin2 = value2.Size() / 2f;
            Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.White * num11;
            color3.A /= 2;
            Microsoft.Xna.Framework.Color color4 = color3 * 0.5f;
            float num13 = 1f;
            float num14 = (num - 1f) / 2f;
            float num15 = rand.NextFloat() * 2f * num;
            num15 += num14;
            float num16 = rand.NextFloatDirection();
            Vector2 vector2 = new Vector2(2.8f + num15 * (1f + num14), 1f) * num13 * num12;
            float value3 = 50f * num;
            Vector2 vector3 = proj.rotation.ToRotationVector2() * ((j >= 1) ? 56 : 0);
            float num17 = 0.03f - (float)j * 0.012f;
            num17 /= num;
            float num18 = 30f + MathHelper.Lerp(0f, value3, num10) + num15 * 16f;
            float num19 = proj.rotation + num16 * ((float)Math.PI * 2f) * num17;
            float rotation = num19;
            Vector2 position2 = vector + num19.ToRotationVector2() * num18 + rand.NextVector2Circular(20f, 20f) + vector3 - screenPosition;
            color2 *= num13;
            color4 *= num13;
            SpriteEffects effects = SpriteEffects.None;
            spriteBatch.Draw(value2, position2, null, color2, rotation, origin2, vector2, effects, 0f);
            spriteBatch.Draw(value2, position2, null, color4, rotation, origin2, vector2 * 0.6f, effects, 0f);
        }
    }
 
    private void DrawProj_FairyQueenLance(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        int num = 40;
        int num2 = 180 * num;
        num2 /= 2;
        Microsoft.Xna.Framework.Color color = proj.AI_171_GetColor();
        Microsoft.Xna.Framework.Color color2 = color;
        color.A = 0;
        color2.A /= 2;
        Texture2D value = TextureAssets.Extra[178].Value;
        Vector2 origin = value.Frame().Size() * new Vector2(0f, 0.5f);
        Vector2 scale = new Vector2(num2 / value.Width, 2f);
        Vector2 scale2 = new Vector2((float)(num2 / value.Width) * 0.5f, 2f);
        Microsoft.Xna.Framework.Color color3 = color * Utils.GetLerpValue(60f, 55f, proj.localAI[0], clamped: true) * Utils.GetLerpValue(0f, 10f, proj.localAI[0], clamped: true);
        spriteBatch.Draw(value, vector, null, color3, proj.rotation, origin, scale2, SpriteEffects.None, 0f);
        spriteBatch.Draw(value, vector, null, color3 * 0.3f, proj.rotation, origin, scale, SpriteEffects.None, 0f);
        Texture2D value2 = TextureAssets.Projectile[proj.type].Value;
        Vector2 origin2 = value2.Frame().Size() / 2f;
        Microsoft.Xna.Framework.Color color4 = Microsoft.Xna.Framework.Color.White * Utils.GetLerpValue(0f, 20f, proj.localAI[0], clamped: true);
        color4.A /= 2;
        float num3 = MathHelper.Lerp(0.7f, 1f, Utils.GetLerpValue(55f, 60f, proj.localAI[0], clamped: true));
        float lerpValue = Utils.GetLerpValue(10f, 60f, proj.localAI[0]);
        if (lerpValue > 0f)
        {
            float lerpValue2 = Utils.GetLerpValue(0f, 1f, proj.velocity.Length(), clamped: true);
            for (float num4 = 1f; num4 > 0f; num4 -= 1f / 6f)
            {
                Vector2 vector2 = proj.rotation.ToRotationVector2() * -120f * num4 * lerpValue2;
                spriteBatch.Draw(value2, vector + vector2, null, color * lerpValue * (1f - num4), proj.rotation, origin2, num3, SpriteEffects.None, 0f);
                spriteBatch.Draw(value2, vector + vector2, null, new Microsoft.Xna.Framework.Color(255, 255, 255, 0) * 0.15f * lerpValue * (1f - num4), proj.rotation, origin2, num3 * 0.85f, SpriteEffects.None, 0f);
            }
            for (float num5 = 0f; num5 < 1f; num5 += 0.25f)
            {
                Vector2 vector3 = (num5 * ((float)Math.PI * 2f) + proj.rotation).ToRotationVector2() * 2f * num3;
                spriteBatch.Draw(value2, vector + vector3, null, color2 * lerpValue, proj.rotation, origin2, num3, SpriteEffects.None, 0f);
            }
            spriteBatch.Draw(value2, vector, null, color2 * lerpValue, proj.rotation, origin2, num3 * 1.1f, SpriteEffects.None, 0f);
        }
        spriteBatch.Draw(value2, vector, null, color4, proj.rotation, origin2, num3, SpriteEffects.None, 0f);
    }
 
    private void DrawProj_FairyQueenRangedItemShot(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Microsoft.Xna.Framework.Color fairyQueenWeaponsColor = proj.GetFairyQueenWeaponsColor(0f);
        Microsoft.Xna.Framework.Color fairyQueenWeaponsColor2 = proj.GetFairyQueenWeaponsColor(0.5f);
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Vector2 origin = value.Frame().Size() / 2f;
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White * proj.Opacity;
        color.A /= 2;
        float num = MathHelper.Lerp(0.7f, 1f, Utils.GetLerpValue(0f, 5f, proj.ai[0], clamped: true));
        float opacity = proj.Opacity;
        if (opacity > 0f)
        {
            float lerpValue = Utils.GetLerpValue(0f, 1f, proj.velocity.Length(), clamped: true);
            for (float num2 = 0f; num2 < 1f; num2 += 1f / 6f)
            {
                Vector2 vector2 = proj.rotation.ToRotationVector2() * -120f * num2 * lerpValue;
                spriteBatch.Draw(value, vector + vector2, null, fairyQueenWeaponsColor * opacity * (1f - num2), proj.rotation, origin, num, SpriteEffects.None, 0f);
            }
            for (float num3 = 0f; num3 < 1f; num3 += 0.25f)
            {
                Vector2 vector3 = (num3 * ((float)Math.PI * 2f) + proj.rotation).ToRotationVector2() * 4f * num;
                spriteBatch.Draw(value, vector + vector3, null, fairyQueenWeaponsColor2 * opacity, proj.rotation, origin, num, SpriteEffects.None, 0f);
            }
        }
        spriteBatch.Draw(value, vector, null, color, proj.rotation, origin, num, SpriteEffects.None, 0f);
    }
 
    private void DrawProj_EmpressBlade(Projectile proj, float hueOverride)
    {
        CurrentDrawnEntityShader = -1;
        PrepareDrawnProjectileDrawing(proj);
        Vector2 vector = proj.Center - screenPosition;
        proj.GetFairyQueenWeaponsColor(0f, 0f, hueOverride);
        Microsoft.Xna.Framework.Color fairyQueenWeaponsColor = proj.GetFairyQueenWeaponsColor(0.5f, 0f, hueOverride);
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Vector2 origin = value.Frame().Size() / 2f;
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White * proj.Opacity;
        color.A = (byte)((float)(int)color.A * 0.7f);
        fairyQueenWeaponsColor.A /= 2;
        float scale = proj.scale;
        float num = proj.rotation - (float)Math.PI / 2f;
        float num2 = proj.Opacity * 0.3f;
        if (num2 > 0f)
        {
            float lerpValue = Utils.GetLerpValue(60f, 50f, proj.ai[0], clamped: true);
            float num3 = Utils.GetLerpValue(70f, 50f, proj.ai[0], clamped: true) * Utils.GetLerpValue(40f, 45f, proj.ai[0], clamped: true);
            for (float num4 = 0f; num4 < 1f; num4 += 1f / 6f)
            {
                Vector2 vector2 = num.ToRotationVector2() * -120f * num4 * lerpValue;
                EntitySpriteDraw(value, vector + vector2, null, fairyQueenWeaponsColor * num2 * (1f - num4) * num3, num, origin, scale * 1.5f, SpriteEffects.None);
            }
            for (float num5 = 0f; num5 < 1f; num5 += 0.25f)
            {
                Vector2 vector3 = (num5 * ((float)Math.PI * 2f) + num).ToRotationVector2() * 4f * scale;
                EntitySpriteDraw(value, vector + vector3, null, fairyQueenWeaponsColor * num2, num, origin, scale, SpriteEffects.None);
            }
        }
        EntitySpriteDraw(value, vector, null, color, num, origin, scale, SpriteEffects.None);
        EntitySpriteDraw(value, vector, null, fairyQueenWeaponsColor * num2 * 0.5f, num, origin, scale, SpriteEffects.None);
    }
 
    private void DrawProj_CoolWhipMinion(Projectile proj)
    {
        Vector2 vector = proj.Center - screenPosition;
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White * 0.5f;
        color.A = 0;
        Microsoft.Xna.Framework.Color color2 = color;
        color2.A = 127;
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Vector2 origin = value.Frame().Size() / 2f;
        Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.White * proj.Opacity;
        color3.A /= 2;
        int num = 1;
        float opacity = proj.Opacity;
        if (opacity > 0f)
        {
            for (float num2 = 0f; num2 < 4f; num2 += 1f)
            {
                Vector2 vector2 = proj.velocity * (0f - num2);
                spriteBatch.Draw(value, vector + vector2, null, color * opacity * ((4f - num2) / 4f), proj.rotation, origin, num, SpriteEffects.None, 0f);
            }
            for (float num3 = 0f; num3 < 1f; num3 += 0.25f)
            {
                Vector2 vector3 = (num3 * ((float)Math.PI * 2f) + proj.rotation).ToRotationVector2() * 4f * num;
                spriteBatch.Draw(value, vector + vector3, null, color2 * opacity, proj.rotation, origin, num, SpriteEffects.None, 0f);
            }
        }
        spriteBatch.Draw(value, vector, null, color3, proj.rotation, origin, num, SpriteEffects.None, 0f);
    }
 
    private void DrawMurderAurora(Projectile proj)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Vector2 origin = value.Size() / 2f;
        float num = GlobalTimeWrappedHourly % 10f / 10f;
        Vector2 vector = proj.Center - screenPosition;
        float[] array = new float[15];
        float[] array2 = new float[15];
        float[] array3 = new float[15];
        float[] array4 = new float[15];
        float[] array5 = new float[15];
        float num2 = 0.5f;
        int num3 = 210;
        num2 = Utils.GetLerpValue(0f, 60f, proj.timeLeft, clamped: true) * Utils.GetLerpValue(num3, num3 - 60, proj.timeLeft, clamped: true);
        float amount = Utils.GetLerpValue(0f, 60f, proj.timeLeft, clamped: true) * Utils.GetLerpValue(num3, 90f, proj.timeLeft, clamped: true);
        amount = MathHelper.Lerp(0.2f, 0.5f, amount);
        float num4 = 800f / (float)value.Width;
        float num5 = num4 * 0.8f;
        float num6 = (num4 - num5) / 15f;
        float num7 = 30f;
        float num8 = 300f;
        Vector2 vector2 = new Vector2(3f, 6f);
        for (int i = 0; i < 15; i++)
        {
            _ = (float)(i + 1) / 50f;
            float num9 = (float)Math.Sin(num * ((float)Math.PI * 2f) + (float)Math.PI / 2f + (float)i / 2f);
            array[i] = num9 * (num8 - (float)i * 3f);
            array2[i] = (float)Math.Sin(num * ((float)Math.PI * 2f) * 2f + (float)Math.PI / 3f + (float)i) * num7;
            array2[i] -= (float)i * 3f;
            array3[i] = (float)i / 15f * 2f + num;
            array3[i] = (num9 * 0.5f + 0.5f) * 0.6f + num;
            array4[i] = (float)(1.0 - Math.Pow(1f * (float)i / 15f, 2.0));
            array5[i] = num5 + (float)(i + 1) * num6;
            array5[i] *= 0.3f;
            Microsoft.Xna.Framework.Color color = hslToRgb(array3[i] % 1f, 1f, 0.5f) * num2 * amount;
            color.A /= 4;
            float rotation = (float)Math.PI / 2f + num9 * ((float)Math.PI / 4f) * -0.3f + (float)Math.PI * (float)i;
            EntitySpriteDraw(value, vector + new Vector2(array[i], array2[i]), null, color, rotation, origin, new Vector2(array5[i], array5[i]) * vector2, SpriteEffects.None);
        }
    }
 
    private void DrawWhip(Projectile proj)
    {
        List<Vector2> list = new List<Vector2>();
        Projectile.FillWhipControlPoints(proj, list);
        Texture2D value = TextureAssets.FishingLine.Value;
        Microsoft.Xna.Framework.Rectangle value2 = value.Frame();
        Vector2 origin = new Vector2(value2.Width / 2, 2f);
        Microsoft.Xna.Framework.Color originalColor = Microsoft.Xna.Framework.Color.White;
        switch (proj.type)
        {
        case 847:
            originalColor = Microsoft.Xna.Framework.Color.OrangeRed;
            break;
        case 849:
            originalColor = Microsoft.Xna.Framework.Color.SlateBlue;
            originalColor = Microsoft.Xna.Framework.Color.Black;
            break;
        case 848:
            originalColor = Microsoft.Xna.Framework.Color.DarkBlue;
            break;
        case 912:
            originalColor = Microsoft.Xna.Framework.Color.LightBlue;
            break;
        case 913:
            originalColor = Microsoft.Xna.Framework.Color.Firebrick;
            break;
        case 914:
            originalColor = Microsoft.Xna.Framework.Color.ForestGreen;
            break;
        case 915:
            originalColor = Microsoft.Xna.Framework.Color.White;
            break;
        case 952:
            originalColor = Microsoft.Xna.Framework.Color.Tan;
            break;
        }
        Vector2 vector = list[0];
        for (int i = 0; i < list.Count - 1; i++)
        {
            Vector2 vector2 = list[i];
            Vector2 vector3 = list[i + 1] - vector2;
            float rotation = vector3.ToRotation() - (float)Math.PI / 2f;
            Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector2.ToTileCoordinates(), originalColor);
            Vector2 scale = new Vector2(1f, (vector3.Length() + 2f) / (float)value2.Height);
            spriteBatch.Draw(value, vector - screenPosition, value2, color, rotation, origin, scale, SpriteEffects.None, 0f);
            vector += vector3;
        }
        switch (proj.type)
        {
        case 847:
            vector = DrawWhip_WhipSword(proj, list);
            break;
        case 841:
            vector = DrawWhip_WhipBland(proj, list);
            break;
        case 848:
            vector = DrawWhip_WhipMace(proj, list);
            break;
        case 849:
            vector = DrawWhip_WhipScythe(proj, list);
            break;
        case 912:
            vector = DrawWhip_CoolWhip(proj, list);
            break;
        case 913:
            vector = DrawWhip_FireWhip(proj, list);
            break;
        case 914:
            vector = DrawWhip_ThornWhip(proj, list);
            break;
        case 915:
            vector = DrawWhip_RainbowWhip(proj, list);
            break;
        case 952:
            vector = DrawWhip_BoneWhip(proj, list);
            break;
        }
    }
 
    public static Vector2 DrawWhip_BoneWhip(Projectile proj, List<Vector2> controlPoints)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = true;
            Vector2 origin = vector;
            switch (i)
            {
            case 0:
                origin.Y -= 4f;
                break;
            case 19:
                rectangle.Y = height * 4;
                break;
            default:
                rectangle.Y = height * (1 + i % 3);
                break;
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color, rotation, origin, 1f, SpriteEffects.None, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_CoolWhip(Projectile proj, List<Vector2> controlPoints)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = true;
            Vector2 origin = vector;
            switch (i)
            {
            case 0:
                origin.Y -= 4f;
                break;
            case 3:
            case 5:
            case 7:
                rectangle.Y = height;
                break;
            case 9:
            case 11:
            case 13:
                rectangle.Y = height * 2;
                break;
            case 15:
            case 17:
                rectangle.Y = height * 3;
                break;
            case 19:
                rectangle.Y = height * 4;
                break;
            default:
                flag = false;
                break;
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color alpha = proj.GetAlpha(Lighting.GetColor(vector3.ToTileCoordinates()));
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, alpha, rotation, origin, 1f, SpriteEffects.None, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_FireWhip(Projectile proj, List<Vector2> controlPoints)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = true;
            Vector2 origin = vector;
            switch (i)
            {
            case 0:
                origin.Y -= 4f;
                break;
            case 3:
            case 5:
            case 7:
                rectangle.Y = height;
                break;
            case 9:
            case 11:
            case 13:
                rectangle.Y = height * 2;
                break;
            case 15:
            case 17:
                rectangle.Y = height * 3;
                break;
            case 19:
                rectangle.Y = height * 4;
                break;
            default:
                flag = false;
                break;
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color alpha = proj.GetAlpha(Lighting.GetColor(vector3.ToTileCoordinates()));
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, alpha, rotation, origin, 1f, SpriteEffects.None, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_RainbowWhip(Projectile proj, List<Vector2> controlPoints)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        float miscCounterNormalized = player[proj.owner].miscCounterNormalized;
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = true;
            Vector2 origin = vector;
            switch (i)
            {
            case 0:
                origin.Y -= 4f;
                break;
            case 39:
                rectangle.Y = height * 4;
                break;
            default:
                flag = i % 2 == 0;
                rectangle.Y = height * (1 + i % 3);
                break;
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                Microsoft.Xna.Framework.Color color = hslToRgb((miscCounterNormalized * 5f + (float)i * 0.05f) % 1f, 1f, 0.5f);
                Microsoft.Xna.Framework.Color color2 = color;
                float lerpValue = Utils.GetLerpValue(controlPoints.Count - 10, controlPoints.Count - 2, i, clamped: true);
                float num = MathHelper.Lerp(1f, 1f, lerpValue);
                color2.A /= 2;
                color2.A = (byte)((float)(int)color2.A * lerpValue);
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color3 = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, Microsoft.Xna.Framework.Color.Lerp(color3, color2, 0.5f), rotation, origin, num, SpriteEffects.None, 0f);
                color2.A = 0;
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color2 * 0.1f, rotation, origin, num * 1.2f, SpriteEffects.None, 0f);
                if (i == 39)
                {
                    color2 = color;
                    color2.A = 127;
                    spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color2 * 0.3f, rotation, origin, num * 1.4f, SpriteEffects.None, 0f);
                }
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_ThornWhip(Projectile proj, List<Vector2> controlPoints)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = true;
            Vector2 origin = vector;
            float scale = 1f;
            switch (i)
            {
            case 0:
                origin.Y -= 4f;
                break;
            case 19:
                rectangle.Y = height * 4;
                scale = 1.1f;
                break;
            default:
                rectangle.Y = height * (1 + i % 3);
                scale = 0.8f;
                break;
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color, rotation, origin, scale, SpriteEffects.None, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_WhipSword(Projectile proj, List<Vector2> controlPoints)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = true;
            Vector2 origin = vector;
            switch (i)
            {
            case 0:
                origin.Y -= 4f;
                break;
            case 3:
            case 5:
            case 7:
                rectangle.Y = height;
                break;
            case 9:
            case 11:
            case 13:
                rectangle.Y = height * 2;
                break;
            case 15:
            case 17:
                rectangle.Y = height * 3;
                break;
            case 19:
                rectangle.Y = height * 4;
                break;
            default:
                flag = false;
                break;
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color, rotation, origin, 1f, SpriteEffects.None, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_WhipMace(Projectile proj, List<Vector2> controlPoints)
    {
        SpriteEffects spriteEffects = SpriteEffects.None;
        if (proj.spriteDirection == 1)
        {
            spriteEffects ^= SpriteEffects.FlipHorizontally;
        }
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = false;
            Vector2 origin = vector;
            float scale = 1f;
            if (i == 0)
            {
                origin.Y -= 4f;
                flag = true;
            }
            else if (i % 2 == 0)
            {
                flag = true;
                int num = 1;
                if (i > 10)
                {
                    num = 2;
                }
                if (i > 20)
                {
                    num = 3;
                }
                rectangle.Y = height * num;
            }
            if (i == controlPoints.Count - 2)
            {
                flag = true;
                rectangle.Y = height * 4;
                scale = 1.3f;
                Projectile.GetWhipSettings(proj, out var timeToFlyOut, out var _, out var _);
                float t = proj.ai[0] / timeToFlyOut;
                float amount = Utils.GetLerpValue(0.1f, 0.7f, t, clamped: true) * Utils.GetLerpValue(0.9f, 0.7f, t, clamped: true);
                scale = MathHelper.Lerp(0.5f, 2f, amount);
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color, rotation, origin, scale, spriteEffects, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_WhipScythe(Projectile proj, List<Vector2> controlPoints)
    {
        SpriteEffects spriteEffects = SpriteEffects.None;
        if (proj.spriteDirection == 1)
        {
            spriteEffects ^= SpriteEffects.FlipHorizontally;
        }
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = false;
            Vector2 origin = vector;
            float scale = 1f;
            if (i == 0)
            {
                origin.Y -= 4f;
                flag = true;
            }
            else if (i % 2 == 0)
            {
                flag = true;
                int num = 1;
                if (i > 10)
                {
                    num = 2;
                }
                if (i > 20)
                {
                    num = 3;
                }
                rectangle.Y = height * num;
            }
            if (i == controlPoints.Count - 2)
            {
                flag = true;
                rectangle.Y = height * 4;
                scale = 1.3f;
                Projectile.GetWhipSettings(proj, out var timeToFlyOut, out var _, out var _);
                float t = proj.ai[0] / timeToFlyOut;
                float amount = Utils.GetLerpValue(0.1f, 0.7f, t, clamped: true) * Utils.GetLerpValue(0.9f, 0.7f, t, clamped: true);
                scale = MathHelper.Lerp(0.5f, 1.5f, amount);
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color, rotation, origin, scale, spriteEffects, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    public static Vector2 DrawWhip_WhipBland(Projectile proj, List<Vector2> controlPoints)
    {
        SpriteEffects spriteEffects = SpriteEffects.None;
        if (proj.spriteDirection == 1)
        {
            spriteEffects ^= SpriteEffects.FlipHorizontally;
        }
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 5);
        int height = rectangle.Height;
        rectangle.Height -= 2;
        Vector2 vector = rectangle.Size() / 2f;
        Vector2 vector2 = controlPoints[0];
        for (int i = 0; i < controlPoints.Count - 1; i++)
        {
            bool flag = false;
            Vector2 origin = vector;
            float scale = 1f;
            if (i == 0)
            {
                origin.Y -= 4f;
                flag = true;
            }
            else
            {
                flag = true;
                int num = 1;
                if (i > 10)
                {
                    num = 2;
                }
                if (i > 20)
                {
                    num = 3;
                }
                rectangle.Y = height * num;
            }
            if (i == controlPoints.Count - 2)
            {
                flag = true;
                rectangle.Y = height * 4;
                scale = 1.3f;
                Projectile.GetWhipSettings(proj, out var timeToFlyOut, out var _, out var _);
                float t = proj.ai[0] / timeToFlyOut;
                float amount = Utils.GetLerpValue(0.1f, 0.7f, t, clamped: true) * Utils.GetLerpValue(0.9f, 0.7f, t, clamped: true);
                scale = MathHelper.Lerp(0.5f, 1.5f, amount);
            }
            Vector2 vector3 = controlPoints[i];
            Vector2 vector4 = controlPoints[i + 1] - vector3;
            if (flag)
            {
                float rotation = vector4.ToRotation() - (float)Math.PI / 2f;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(vector3.ToTileCoordinates());
                spriteBatch.Draw(value, vector2 - screenPosition, rectangle, color, rotation, origin, scale, spriteEffects, 0f);
            }
            vector2 += vector4;
        }
        return vector2;
    }
 
    private void DrawTwinsPet(Projectile proj)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        SpriteEffects effects = ((proj.spriteDirection != 1) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, projFrames[proj.type], 0, proj.frame);
        Vector2 origin = rectangle.Size() / 2f;
        Vector2 vector = proj.Center - screenPosition;
        Microsoft.Xna.Framework.Color alpha = proj.GetAlpha(Lighting.GetColor(proj.Center.ToTileCoordinates()));
        float num = 18f;
        if (proj.isAPreviewDummy)
        {
            num = 8f;
        }
        Vector2 position = vector + (GlobalTimeWrappedHourly * 2f).ToRotationVector2() * num;
        EntitySpriteDraw(value, position, rectangle, alpha, proj.rotation, origin, proj.scale, effects);
        position = vector - (GlobalTimeWrappedHourly * 2f).ToRotationVector2() * num;
        rectangle = value.Frame(1, projFrames[proj.type], 0, proj.frame + 18);
        EntitySpriteDraw(value, position, rectangle, alpha, proj.rotation, origin, proj.scale, effects);
    }
 
    private void DrawMultisegmentPet(Projectile proj)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Texture2D texture2D = null;
        if (proj.type == 887)
        {
            texture2D = TextureAssets.GlowMask[275].Value;
        }
        int num = 5;
        int num2 = 16;
        switch (proj.type)
        {
        case 883:
            num = 5;
            num2 = 16;
            break;
        case 887:
            num = 6;
            num2 = 16;
            break;
        case 893:
            num = 8;
            num2 = 20;
            break;
        }
        SpriteEffects effects = ((proj.spriteDirection != 1) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, projFrames[proj.type]);
        Vector2 origin = rectangle.Size() / 2f;
        Vector2 position = proj.Center - screenPosition;
        Microsoft.Xna.Framework.Color alpha = proj.GetAlpha(Lighting.GetColor(proj.Center.ToTileCoordinates()));
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White * ((float)(int)mouseTextColor / 255f);
        Vector2 vector = proj.Center;
        int num3 = 1;
        int num4 = projFrames[proj.type] - 1;
        for (int i = 1; i < num; i++)
        {
            int frameY = num3;
            if (i == num - 1)
            {
                frameY = num4;
            }
            else if (proj.type == 893 && i != 2 && i != 5)
            {
                frameY = 2;
            }
            Microsoft.Xna.Framework.Rectangle value2 = value.Frame(1, projFrames[proj.type], 0, frameY);
            Vector2 vector2 = proj.oldPos[i * 10] + proj.Size / 2f;
            float num5 = (vector - vector2).ToRotation();
            vector2 = vector - new Vector2(num2, 0f).RotatedBy(num5, Vector2.Zero);
            num5 = (vector - vector2).ToRotation() + (float)Math.PI / 2f;
            Vector2 position2 = vector2 - screenPosition;
            SpriteEffects effects2 = ((!(vector2.X < vector.X)) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
            vector = vector2;
            EntitySpriteDraw(value, position2, value2, proj.GetAlpha(Lighting.GetColor(vector2.ToTileCoordinates())), num5, origin, proj.scale, effects2);
            if (texture2D != null)
            {
                EntitySpriteDraw(texture2D, position2, value2, proj.GetAlpha(color), num5, origin, proj.scale, effects2);
            }
        }
        EntitySpriteDraw(value, position, rectangle, alpha, proj.rotation, origin, proj.scale, effects);
        if (texture2D != null)
        {
            EntitySpriteDraw(texture2D, position, rectangle, color, proj.rotation, origin, proj.scale, effects);
        }
    }
 
    private void DrawKite(Projectile proj)
    {
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        Texture2D value2 = TextureAssets.Extra[103].Value;
        int num = 15;
        float num2 = 0f;
        int num3 = 10;
        int num4 = 5;
        float num5 = 10f;
        float num6 = 0f;
        int num7 = -14;
        int num8 = -2;
        int num9 = -1;
        int num10 = -1;
        int num11 = 8;
        int num12 = 0;
        int num13 = 1;
        int num14 = 0;
        int num15 = 0;
        bool flag = true;
        bool flag2 = false;
        switch (proj.type)
        {
        case 771:
            value2 = TextureAssets.Extra[104].Value;
            num = 12;
            num12 = 12;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 12;
            num5 = 22f;
            num6 += (float)Math.PI / 8f * (float)proj.spriteDirection;
            num7 = -8;
            num8 = -6;
            num9 = 10;
            num10 = 8;
            num11 = 12;
            break;
        case 822:
            value2 = TextureAssets.Extra[132].Value;
            num = 7;
            num12 = 7;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 7;
            num5 = 22f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num7 = -20;
            num8 = -6;
            num11 = 12;
            break;
        case 850:
            value2 = TextureAssets.Extra[147].Value;
            num = 8;
            num12 = 8;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 8;
            num5 = 22f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num7 = -20;
            num8 = -38;
            num11 = 12;
            num14 = 6;
            num15 = 2;
            flag = false;
            break;
        case 823:
        case 846:
            value2 = TextureAssets.Extra[133].Value;
            if (proj.type == 846)
            {
                value2 = TextureAssets.Extra[146].Value;
            }
            num = 6;
            num12 = 6;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 6;
            num5 = 40f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num7 = -16;
            num8 = -10;
            num11 = 30;
            break;
        case 827:
        case 844:
            value2 = TextureAssets.Extra[135].Value;
            if (proj.type == 844)
            {
                value2 = TextureAssets.Extra[144].Value;
            }
            num = 4;
            num12 = 3;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 16;
            num5 = 10f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num8 = -4;
            num4 = 4;
            flag2 = true;
            break;
        case 828:
        case 829:
            value2 = TextureAssets.Extra[136].Value;
            if (proj.type == 829)
            {
                value2 = TextureAssets.Extra[137].Value;
            }
            num = 2;
            num12 = 1;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 6;
            num5 = 10f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num11 = 10;
            num8 = -4;
            num13 = 3;
            flag = false;
            flag2 = true;
            break;
        case 852:
            value2 = TextureAssets.Extra[148].Value;
            num = 2;
            num12 = 1;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 6;
            num5 = 10f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num11 = 10;
            num8 = -4;
            num13 = 4;
            flag = false;
            flag2 = true;
            break;
        case 830:
        case 838:
            value2 = TextureAssets.Extra[138].Value;
            if (proj.type == 838)
            {
                value2 = TextureAssets.Extra[139].Value;
            }
            num = 3;
            num12 = 3;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 3;
            num5 = 60f;
            num10 = 40;
            num9 = 3;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num11 = 50;
            num8 = -20;
            num14 = -10;
            break;
        case 843:
            value2 = TextureAssets.Extra[140].Value;
            num = 2;
            num12 = 2;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 2;
            num5 = 30f;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num11 = 20;
            num8 = -16;
            num14 = -10;
            break;
        case 845:
            value2 = TextureAssets.Extra[145].Value;
            num = 3;
            num12 = 3;
            num2 = ((proj.spriteDirection == 1) ? ((float)Math.PI / 2f) : (-(float)Math.PI / 2f));
            num3 = 3;
            num5 = 42f;
            num10 = 50;
            num9 = 2;
            num6 += (float)Math.PI / 12f * (float)proj.spriteDirection;
            num11 = 30;
            num8 = -8;
            num14 = -10;
            break;
        case 824:
        case 826:
        case 839:
        case 840:
        case 853:
            num13 = 0;
            break;
        case 766:
        case 767:
        case 768:
        case 769:
        case 770:
            num12 = (proj.type - 766) * 3 + 3;
            break;
        }
        SpriteEffects effects = ((proj.spriteDirection != 1) ? SpriteEffects.FlipHorizontally : SpriteEffects.None);
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(projFrames[proj.type], 1, proj.frame);
        Vector2 origin = rectangle.Size() / 2f;
        Vector2 position = proj.Center - screenPosition;
        Microsoft.Xna.Framework.Color color = Lighting.GetColor(proj.Center.ToTileCoordinates());
        Microsoft.Xna.Framework.Color alpha = proj.GetAlpha(color);
        Texture2D value3 = TextureAssets.FishingLine.Value;
        Microsoft.Xna.Framework.Rectangle value4 = value3.Frame();
        Vector2 origin2 = new Vector2(value4.Width / 2, 2f);
        Microsoft.Xna.Framework.Rectangle rectangle2 = value2.Frame(num);
        int width = rectangle2.Width;
        rectangle2.Width -= 2;
        Vector2 origin3 = rectangle2.Size() / 2f;
        rectangle2.X = width * (num - 1);
        Vector2 playerArmPosition = GetPlayerArmPosition(proj);
        Vector2 center = proj.Center;
        Vector2.Distance(center, playerArmPosition);
        float num16 = 12f;
        _ = (playerArmPosition - center).SafeNormalize(Vector2.Zero) * num16;
        Vector2 vector = playerArmPosition;
        Vector2 vector2 = center - vector;
        Vector2 velocity = proj.velocity;
        if (Math.Abs(velocity.X) > Math.Abs(velocity.Y))
        {
            Utils.Swap(ref velocity.X, ref velocity.Y);
        }
        float num17 = vector2.Length();
        float num18 = 16f;
        float num19 = 80f;
        bool flag3 = true;
        if (num17 == 0f)
        {
            flag3 = false;
        }
        else
        {
            vector2 *= 12f / num17;
            vector -= vector2;
            vector2 = center - vector;
        }
        while (flag3)
        {
            float num20 = 12f;
            float num21 = vector2.Length();
            float num22 = num21;
            if (float.IsNaN(num21) || num21 == 0f)
            {
                flag3 = false;
                continue;
            }
            if (num21 < 20f)
            {
                num20 = num21 - 8f;
                flag3 = false;
            }
            num21 = 12f / num21;
            vector2 *= num21;
            vector += vector2;
            vector2 = center - vector;
            if (num22 > 12f)
            {
                float num23 = 0.3f;
                float num24 = Math.Abs(velocity.X) + Math.Abs(velocity.Y);
                if (num24 > num18)
                {
                    num24 = num18;
                }
                num24 = 1f - num24 / num18;
                num23 *= num24;
                num24 = num22 / num19;
                if (num24 > 1f)
                {
                    num24 = 1f;
                }
                num23 *= num24;
                if (num23 < 0f)
                {
                    num23 = 0f;
                }
                num24 = 1f;
                num23 *= num24;
                if (vector2.Y > 0f)
                {
                    vector2.Y *= 1f + num23;
                    vector2.X *= 1f - num23;
                }
                else
                {
                    num24 = Math.Abs(velocity.X) / 3f;
                    if (num24 > 1f)
                    {
                        num24 = 1f;
                    }
                    num24 -= 0.5f;
                    num23 *= num24;
                    if (num23 > 0f)
                    {
                        num23 *= 2f;
                    }
                    vector2.Y *= 1f + num23;
                    vector2.X *= 1f - num23;
                }
            }
            float rotation = vector2.ToRotation() - (float)Math.PI / 2f;
            if (!flag3)
            {
                value4.Height = (int)num20;
            }
            Microsoft.Xna.Framework.Color color2 = Lighting.GetColor(center.ToTileCoordinates());
            EntitySpriteDraw(value3, vector - screenPosition, value4, color2, rotation, origin2, 1f, SpriteEffects.None);
        }
        Vector2 vector3 = proj.Size / 2f;
        float num25 = Math.Abs(WindForVisuals);
        float num26 = MathHelper.Lerp(0.5f, 1f, num25);
        float num27 = num25;
        if (vector2.Y >= -0.02f && vector2.Y < 1f)
        {
            num27 = Utils.GetLerpValue(0.2f, 0.5f, num25, clamped: true);
        }
        int num28 = num4;
        int num29 = num3 + 1;
        for (int i = 0; i < num13; i++)
        {
            rectangle2.X = width * (num - 1);
            List<Vector2> list = new List<Vector2>();
            Vector2 vector4 = new Vector2(num26 * (float)num11 * (float)proj.spriteDirection, (float)Math.Sin(timeForVisualEffects / 300.0 * 6.2831854820251465) * num27) * 2f;
            float num30 = num7 + num14;
            float num31 = num8 + num15;
            switch (i)
            {
            case 1:
                vector4 = new Vector2(num26 * (float)num11 * (float)proj.spriteDirection, (float)Math.Sin(timeForVisualEffects / 300.0 * 6.2831854820251465) * num27 + 0.5f) * 2f;
                num30 -= 8f;
                num31 -= 8f;
                break;
            case 2:
                vector4 = new Vector2(num26 * (float)num11 * (float)proj.spriteDirection, (float)Math.Sin(timeForVisualEffects / 300.0 * 6.2831854820251465) * num27 + 1f) * 2f;
                num30 -= 4f;
                num31 -= 4f;
                break;
            case 3:
                vector4 = new Vector2(num26 * (float)num11 * (float)proj.spriteDirection, (float)Math.Sin(timeForVisualEffects / 300.0 * 6.2831854820251465) * num27 + 1.5f) * 2f;
                num30 -= 12f;
                num31 -= 12f;
                break;
            }
            Vector2 vector5 = proj.Center + new Vector2(((float)rectangle.Width * 0.5f + num30) * (float)proj.spriteDirection, num31).RotatedBy(proj.rotation + num6);
            list.Add(vector5);
            int num32 = num28;
            int num33 = 1;
            while (num32 < num29 * num28)
            {
                if (num9 != -1 && num9 == num33)
                {
                    num5 = num10;
                }
                Vector2 vector6 = proj.oldPos[num32];
                if (vector6.X == 0f && vector6.Y == 0f)
                {
                    list.Add(vector5);
                }
                else
                {
                    vector6 += vector3 + new Vector2(((float)rectangle.Width * 0.5f + num30) * (float)proj.oldSpriteDirection[num32], num31).RotatedBy(proj.oldRot[num32] + num6);
                    vector6 += vector4 * (num33 + 1);
                    Vector2 vector7 = vector5 - vector6;
                    float num34 = vector7.Length();
                    if (num34 > num5)
                    {
                        vector7 *= num5 / num34;
                    }
                    vector6 = vector5 - vector7;
                    list.Add(vector6);
                    vector5 = vector6;
                }
                num32 += num28;
                num33++;
            }
            if (flag)
            {
                Microsoft.Xna.Framework.Rectangle value5 = value3.Frame();
                for (int num35 = list.Count - 2; num35 >= 0; num35--)
                {
                    Vector2 vector8 = list[num35];
                    Vector2 v = list[num35 + 1] - vector8;
                    float num36 = v.Length();
                    if (!(num36 < 2f))
                    {
                        float rotation2 = v.ToRotation() - (float)Math.PI / 2f;
                        EntitySpriteDraw(value3, vector8 - screenPosition, value5, alpha, rotation2, origin2, new Vector2(1f, num36 / (float)value5.Height), SpriteEffects.None);
                    }
                }
            }
            for (int num37 = list.Count - 2; num37 >= 0; num37--)
            {
                Vector2 vector9 = list[num37];
                Vector2 vector10 = list[num37 + 1];
                Vector2 v2 = vector10 - vector9;
                v2.Length();
                float rotation3 = v2.ToRotation() - (float)Math.PI / 2f + num2;
                EntitySpriteDraw(value2, vector10 - screenPosition, rectangle2, alpha, rotation3, origin3, proj.scale, effects);
                rectangle2.X -= width;
                if (rectangle2.X < 0)
                {
                    int num38 = num12;
                    if (flag2)
                    {
                        num38--;
                    }
                    rectangle2.X = num38 * width;
                }
            }
        }
        EntitySpriteDraw(value, position, rectangle, alpha, proj.rotation + num6, origin, proj.scale, effects);
    }
 
    public static Vector2 GetPlayerArmPosition(Projectile proj)
    {
        Player player = Main.player[proj.owner];
        Vector2 vector = OffsetsPlayerOnhand[player.bodyFrame.Y / 56] * 2f;
        if (player.direction != 1)
        {
            vector.X = (float)player.bodyFrame.Width - vector.X;
        }
        if (player.gravDir != 1f)
        {
            vector.Y = (float)player.bodyFrame.Height - vector.Y;
        }
        vector -= new Vector2(player.bodyFrame.Width - player.width, player.bodyFrame.Height - 42) / 2f;
        Vector2 pos = player.MountedCenter - new Vector2(20f, 42f) / 2f + vector + Vector2.UnitY * player.gfxOffY;
        if (player.mount.Active && player.mount.Type == 52)
        {
            pos.Y -= player.mount.PlayerOffsetHitbox;
            pos += new Vector2(12 * player.direction, -12f);
        }
        return player.RotatedRelativePoint(pos);
    }
 
    private void DrawProjWithStarryTrail(Projectile proj, Microsoft.Xna.Framework.Color projectileColor, SpriteEffects dir)
    {
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(255, 255, 255, projectileColor.A - proj.alpha);
        Vector2 vector = proj.velocity;
        Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Blue * 0.1f;
        Vector2 spinningpoint = new Vector2(0f, -4f);
        float num = 0f;
        float t = vector.Length();
        float num2 = Utils.GetLerpValue(3f, 5f, t, clamped: true);
        bool flag = true;
        if (proj.type == 856 || proj.type == 857)
        {
            vector = proj.position - proj.oldPos[1];
            float num3 = vector.Length();
            if (num3 == 0f)
            {
                vector = Vector2.UnitY;
            }
            else
            {
                vector *= 5f / num3;
            }
            Vector2 origin = new Vector2(proj.ai[0], proj.ai[1]);
            Vector2 center = player[proj.owner].Center;
            float lerpValue = Utils.GetLerpValue(0f, 120f, origin.Distance(center), clamped: true);
            float num4 = 90f;
            if (proj.type == 857)
            {
                num4 = 60f;
                flag = false;
            }
            float lerpValue2 = Utils.GetLerpValue(num4, num4 * (5f / 6f), proj.localAI[0], clamped: true);
            float lerpValue3 = Utils.GetLerpValue(0f, 120f, proj.Center.Distance(center), clamped: true);
            lerpValue *= lerpValue3;
            lerpValue2 *= Utils.GetLerpValue(0f, 15f, proj.localAI[0], clamped: true);
            color2 = Microsoft.Xna.Framework.Color.HotPink * 0.15f * (lerpValue2 * lerpValue);
            if (proj.type == 857)
            {
                color2 = proj.GetFirstFractalColor() * 0.15f * (lerpValue2 * lerpValue);
            }
            spinningpoint = new Vector2(0f, -2f);
            float lerpValue4 = Utils.GetLerpValue(num4, num4 * (2f / 3f), proj.localAI[0], clamped: true);
            lerpValue4 *= Utils.GetLerpValue(0f, 20f, proj.localAI[0], clamped: true);
            num = -0.3f * (1f - lerpValue4);
            num += -1f * Utils.GetLerpValue(15f, 0f, proj.localAI[0], clamped: true);
            num *= lerpValue;
            num2 = lerpValue2 * lerpValue;
        }
        Vector2 vector2 = proj.Center + vector;
        Texture2D value = TextureAssets.Projectile[proj.type].Value;
        _ = new Microsoft.Xna.Framework.Rectangle(0, 0, value.Width, value.Height).Size() / 2f;
        Texture2D value2 = TextureAssets.Extra[91].Value;
        Microsoft.Xna.Framework.Rectangle value3 = value2.Frame();
        Vector2 origin2 = new Vector2((float)value3.Width / 2f, 10f);
        _ = Microsoft.Xna.Framework.Color.Cyan * 0.5f * num2;
        Vector2 vector3 = new Vector2(0f, proj.gfxOffY);
        float num5 = (float)timeForVisualEffects / 60f;
        Vector2 vector4 = vector2 + vector * 0.5f;
        Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.White * 0.5f * num2;
        color3.A = 0;
        Microsoft.Xna.Framework.Color color4 = color2 * num2;
        color4.A = 0;
        Microsoft.Xna.Framework.Color color5 = color2 * num2;
        color5.A = 0;
        Microsoft.Xna.Framework.Color color6 = color2 * num2;
        color6.A = 0;
        float num6 = vector.ToRotation();
        EntitySpriteDraw(value2, vector4 - screenPosition + vector3 + spinningpoint.RotatedBy((float)Math.PI * 2f * num5), value3, color4, num6 + (float)Math.PI / 2f, origin2, 1.5f + num, SpriteEffects.None);
        EntitySpriteDraw(value2, vector4 - screenPosition + vector3 + spinningpoint.RotatedBy((float)Math.PI * 2f * num5 + (float)Math.PI * 2f / 3f), value3, color5, num6 + (float)Math.PI / 2f, origin2, 1.1f + num, SpriteEffects.None);
        EntitySpriteDraw(value2, vector4 - screenPosition + vector3 + spinningpoint.RotatedBy((float)Math.PI * 2f * num5 + 4.1887903f), value3, color6, num6 + (float)Math.PI / 2f, origin2, 1.3f + num, SpriteEffects.None);
        Vector2 vector5 = vector2 - vector * 0.5f;
        for (float num7 = 0f; num7 < 1f; num7 += 0.5f)
        {
            float num8 = num5 % 0.5f / 0.5f;
            num8 = (num8 + num7) % 1f;
            float num9 = num8 * 2f;
            if (num9 > 1f)
            {
                num9 = 2f - num9;
            }
            EntitySpriteDraw(value2, vector5 - screenPosition + vector3, value3, color3 * num9, num6 + (float)Math.PI / 2f, origin2, 0.3f + num8 * 0.5f, SpriteEffects.None);
        }
        if (flag)
        {
            float rotation = proj.rotation + proj.localAI[1];
            _ = (float)timeForVisualEffects / 240f;
            _ = GlobalTimeWrappedHourly;
            float globalTimeWrappedHourly = GlobalTimeWrappedHourly;
            globalTimeWrappedHourly %= 5f;
            globalTimeWrappedHourly /= 2.5f;
            if (globalTimeWrappedHourly >= 1f)
            {
                globalTimeWrappedHourly = 2f - globalTimeWrappedHourly;
            }
            globalTimeWrappedHourly = globalTimeWrappedHourly * 0.5f + 0.5f;
            Vector2 position = proj.Center - screenPosition;
            instance.LoadItem(75);
            Texture2D value4 = TextureAssets.Item[75].Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value4.Frame(1, 8);
            EntitySpriteDraw(origin: rectangle.Size() / 2f, texture: value4, position: position, sourceRectangle: rectangle, color: color, rotation: rotation, scale: proj.scale, effects: SpriteEffects.None);
        }
    }
 
    private static int TryInteractingWithVoidLens(Projectile proj)
    {
        if (gamePaused || gameMenu)
        {
            return 0;
        }
        bool flag = !SmartCursorIsUsed && !PlayerInput.UsingGamepad;
        Player localPlayer = LocalPlayer;
        Microsoft.Xna.Framework.Point point = proj.Center.ToTileCoordinates();
        Vector2 compareSpot = localPlayer.Center;
        if (!localPlayer.IsProjectileInteractibleAndInInteractionRange(proj, ref compareSpot))
        {
            return 0;
        }
        Matrix matrix = Matrix.Invert(GameViewMatrix.ZoomMatrix);
        Vector2 position = ReverseGravitySupport(MouseScreen);
        Vector2.Transform(screenPosition, matrix);
        Vector2 v = Vector2.Transform(position, matrix) + screenPosition;
        bool flag2 = proj.Hitbox.Contains(v.ToPoint());
        if (!((flag2 || SmartInteractProj == proj.whoAmI) & !localPlayer.lastMouseInterface))
        {
            if (!flag)
            {
                return 1;
            }
            return 0;
        }
        HasInteractibleObjectThatIsNotATile = true;
        if (flag2)
        {
            localPlayer.noThrow = 2;
            localPlayer.cursorItemIconEnabled = true;
            localPlayer.cursorItemIconID = 4131;
        }
        if (PlayerInput.UsingGamepad)
        {
            localPlayer.GamepadEnableGrappleCooldown();
        }
        if (mouseRight && mouseRightRelease && Player.BlockInteractionWithProjectiles == 0)
        {
            mouseRightRelease = false;
            localPlayer.tileInteractAttempted = true;
            localPlayer.tileInteractionHappened = true;
            localPlayer.releaseUseTile = false;
            if (localPlayer.chest == -5)
            {
                localPlayer.chest = -1;
                SoundEngine.PlaySound(SoundID.Item130);
                Recipe.FindRecipes();
            }
            else if (localPlayer.disableVoidBag < 0)
            {
                localPlayer.chest = -5;
                for (int i = 0; i < 40; i++)
                {
                    ItemSlot.SetGlow(i, -1f, chest: true);
                }
                localPlayer.voidLensChest.Set(proj);
                localPlayer.chestX = point.X;
                localPlayer.chestY = point.Y;
                localPlayer.SetTalkNPC(-1);
                SetNPCShopIndex(0);
                playerInventory = true;
                SoundEngine.PlaySound(SoundID.Item130);
                Recipe.FindRecipes();
            }
        }
        if (!SmartCursorIsUsed && !PlayerInput.UsingGamepad)
        {
            return 0;
        }
        if (!flag)
        {
            return 2;
        }
        return 0;
    }
 
    private static int TryInteractingWithMoneyTrough(Projectile proj)
    {
        if (gamePaused || gameMenu)
        {
            return 0;
        }
        bool flag = !SmartCursorIsUsed && !PlayerInput.UsingGamepad;
        Player localPlayer = LocalPlayer;
        Microsoft.Xna.Framework.Point point = proj.Center.ToTileCoordinates();
        Vector2 compareSpot = localPlayer.Center;
        if (!localPlayer.IsProjectileInteractibleAndInInteractionRange(proj, ref compareSpot))
        {
            return 0;
        }
        Matrix matrix = Matrix.Invert(GameViewMatrix.ZoomMatrix);
        Vector2 position = ReverseGravitySupport(MouseScreen);
        Vector2.Transform(screenPosition, matrix);
        Vector2 v = Vector2.Transform(position, matrix) + screenPosition;
        bool flag2 = proj.Hitbox.Contains(v.ToPoint());
        if (!((flag2 || SmartInteractProj == proj.whoAmI) & !localPlayer.lastMouseInterface))
        {
            if (!flag)
            {
                return 1;
            }
            return 0;
        }
        HasInteractibleObjectThatIsNotATile = true;
        if (flag2)
        {
            localPlayer.noThrow = 2;
            localPlayer.cursorItemIconEnabled = true;
            localPlayer.cursorItemIconID = 3213;
            if (proj.type == 960)
            {
                localPlayer.cursorItemIconID = 5098;
            }
        }
        if (PlayerInput.UsingGamepad)
        {
            localPlayer.GamepadEnableGrappleCooldown();
        }
        if (mouseRight && mouseRightRelease && Player.BlockInteractionWithProjectiles == 0)
        {
            mouseRightRelease = false;
            localPlayer.tileInteractAttempted = true;
            localPlayer.tileInteractionHappened = true;
            localPlayer.releaseUseTile = false;
            if (localPlayer.chest == -2)
            {
                localPlayer.chest = -1;
                PlayInteractiveProjectileOpenCloseSound(proj.type, open: false);
                Recipe.FindRecipes();
            }
            else
            {
                localPlayer.chest = -2;
                for (int i = 0; i < 40; i++)
                {
                    ItemSlot.SetGlow(i, -1f, chest: true);
                }
                localPlayer.piggyBankProjTracker.Set(proj);
                localPlayer.chestX = point.X;
                localPlayer.chestY = point.Y;
                localPlayer.SetTalkNPC(-1);
                SetNPCShopIndex(0);
                playerInventory = true;
                PlayInteractiveProjectileOpenCloseSound(proj.type, open: true);
                Recipe.FindRecipes();
            }
        }
        if (!SmartCursorIsUsed && !PlayerInput.UsingGamepad)
        {
            return 0;
        }
        if (!flag)
        {
            return 2;
        }
        return 0;
    }
 
    public static void PlayInteractiveProjectileOpenCloseSound(int projType, bool open)
    {
        switch (projType)
        {
        case 525:
            SoundEngine.PlaySound(SoundID.Item59);
            break;
        case 960:
            SoundEngine.PlaySound(open ? SoundID.ChesterOpen : SoundID.ChesterClose);
            break;
        }
    }
 
    public static void PrintTimedMessage(string message, params object[] arguments)
    {
        Console.WriteLine($"{(int)time} {string.Format(message, arguments)}");
    }
 
    private static void TryInteractingWithMoneyTrough2(Projectile proj)
    {
        if (gamePaused && !gameMenu)
        {
            return;
        }
        Vector2 vector = proj.position - screenPosition;
        if (!((float)mouseX > vector.X) || !((float)mouseX < vector.X + (float)proj.width) || !((float)mouseY > vector.Y) || !((float)mouseY < vector.Y + (float)proj.height))
        {
            return;
        }
        int num = (int)(player[myPlayer].Center.X / 16f);
        int num2 = (int)(player[myPlayer].Center.Y / 16f);
        int num3 = (int)proj.Center.X / 16;
        int num4 = (int)proj.Center.Y / 16;
        int lastTileRangeX = player[myPlayer].lastTileRangeX;
        int lastTileRangeY = player[myPlayer].lastTileRangeY;
        if (num < num3 - lastTileRangeX || num > num3 + lastTileRangeX + 1 || num2 < num4 - lastTileRangeY || num2 > num4 + lastTileRangeY + 1)
        {
            return;
        }
        Player localPlayer = LocalPlayer;
        player[myPlayer].noThrow = 2;
        player[myPlayer].cursorItemIconEnabled = true;
        player[myPlayer].cursorItemIconID = 3213;
        if (PlayerInput.UsingGamepad)
        {
            player[myPlayer].GamepadEnableGrappleCooldown();
        }
        if (mouseRight && mouseRightRelease && Player.BlockInteractionWithProjectiles == 0)
        {
            mouseRightRelease = false;
            localPlayer.tileInteractAttempted = true;
            localPlayer.tileInteractionHappened = true;
            localPlayer.releaseUseTile = false;
            if (player[myPlayer].chest == -2)
            {
                SoundEngine.PlaySound(SoundID.Item59);
                player[myPlayer].chest = -1;
                Recipe.FindRecipes();
                return;
            }
            player[myPlayer].piggyBankProjTracker.Set(proj);
            player[myPlayer].chest = -2;
            player[myPlayer].chestX = (int)(proj.Center.X / 16f);
            player[myPlayer].chestY = (int)(proj.Center.Y / 16f);
            player[myPlayer].SetTalkNPC(-1);
            SetNPCShopIndex(0);
            playerInventory = true;
            SoundEngine.PlaySound(SoundID.Item59);
            Recipe.FindRecipes();
        }
    }
 
    public void PrepareDrawnProjectileDrawing(Projectile proj)
    {
        CurrentDrawnEntity = proj;
        int projectileDesiredShader = GetProjectileDesiredShader(proj);
        Matrix value = Transform;
        if (proj.isAPreviewDummy)
        {
            value = UIScaleMatrix;
        }
        PrepareDrawnEntityDrawing(proj, projectileDesiredShader, value);
    }
 
    public void PrepareDrawnEntityDrawing(Entity entity, int intendedShader, Matrix? overrideMatrix)
    {
        CurrentDrawnEntity = entity;
        Matrix transformMatrix = Transform;
        if (overrideMatrix.HasValue)
        {
            transformMatrix = overrideMatrix.Value;
        }
        if (intendedShader != 0)
        {
            if (CurrentDrawnEntityShader == 0 || CurrentDrawnEntityShader == -1)
            {
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, base.GraphicsDevice.RasterizerState, null, transformMatrix);
            }
        }
        else if (CurrentDrawnEntityShader != 0 && CurrentDrawnEntityShader != -1)
        {
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, base.GraphicsDevice.RasterizerState, null, transformMatrix);
        }
        CurrentDrawnEntityShader = intendedShader;
    }
 
    public static void EntitySpriteDraw(Texture2D texture, Vector2 position, Microsoft.Xna.Framework.Rectangle? sourceRectangle, Microsoft.Xna.Framework.Color color, float rotation, Vector2 origin, float scale, SpriteEffects effects, float worthless = 0f)
    {
        EntitySpriteDraw(texture, position, sourceRectangle, color, rotation, origin, new Vector2(scale), effects, worthless);
    }
 
    public static void EntitySpriteDraw(Texture2D texture, Vector2 position, Microsoft.Xna.Framework.Rectangle? sourceRectangle, Microsoft.Xna.Framework.Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float worthless = 0f)
    {
        if (CurrentDrawnEntityShader > 0)
        {
            DrawData value = new DrawData(texture, position, sourceRectangle, color, rotation, origin, scale, effects, worthless);
            GameShaders.Armor.Apply(CurrentDrawnEntityShader, CurrentDrawnEntity, value);
            value.Draw(spriteBatch);
        }
        else
        {
            spriteBatch.Draw(texture, position, sourceRectangle, color, rotation, origin, scale, effects, worthless);
        }
    }
 
    public static void EntitySpriteDraw(DrawData data)
    {
        if (CurrentDrawnEntityShader > 0)
        {
            GameShaders.Armor.Apply(CurrentDrawnEntityShader, CurrentDrawnEntity, data);
            data.Draw(spriteBatch);
        }
        else
        {
            data.Draw(spriteBatch);
        }
    }
 
    public static Microsoft.Xna.Framework.Color buffColor(Microsoft.Xna.Framework.Color newColor, float R, float G, float B, float A)
    {
        newColor.R = (byte)((float)(int)newColor.R * R);
        newColor.G = (byte)((float)(int)newColor.G * G);
        newColor.B = (byte)((float)(int)newColor.B * B);
        newColor.A = (byte)((float)(int)newColor.A * A);
        return newColor;
    }
 
    protected void CacheNPCDraws()
    {
        DrawCacheNPCsMoonMoon.Clear();
        DrawCacheNPCsOverPlayers.Clear();
        DrawCacheNPCProjectiles.Clear();
        DrawCacheNPCsBehindNonSolidTiles.Clear();
        for (int i = 0; i < 200; i++)
        {
            if (!npc[i].active)
            {
                continue;
            }
            if (npc[i].type == 398 && npc[i].ai[0] >= 0f)
            {
                int num = i;
                int num2 = -1;
                int num3 = -1;
                int num4 = -1;
                for (int j = 0; j < 200; j++)
                {
                    if (npc[j].active && npc[j].ai[3] == (float)num)
                    {
                        if (num2 == -1 && npc[j].type == 397 && npc[j].ai[2] == 0f)
                        {
                            num2 = j;
                        }
                        if (num3 == -1 && npc[j].type == 397 && npc[j].ai[2] == 1f)
                        {
                            num3 = j;
                        }
                        if (num4 == -1 && npc[j].type == 396)
                        {
                            num4 = j;
                        }
                        if (num2 != -1 && num3 != -1 && num4 != -1)
                        {
                            break;
                        }
                    }
                }
                if (num2 != -1 && num3 != -1 && num4 != -1)
                {
                    DrawCacheNPCsMoonMoon.Add(num);
                    if (num2 != -1)
                    {
                        DrawCacheNPCsMoonMoon.Add(num2);
                    }
                    if (num3 != -1)
                    {
                        DrawCacheNPCsMoonMoon.Add(num3);
                    }
                    if (num4 != -1)
                    {
                        DrawCacheNPCsMoonMoon.Add(num4);
                    }
                }
            }
            else if (npc[i].type == 421 && npc[i].ai[0] == 5f)
            {
                DrawCacheNPCsOverPlayers.Add(i);
            }
            else if (npc[i].type == 516 || npc[i].type == 519)
            {
                DrawCacheNPCProjectiles.Add(i);
            }
            else if (npc[i].type == 548)
            {
                DrawCacheNPCsBehindNonSolidTiles.Add(i);
            }
        }
    }
 
    protected void CacheProjDraws()
    {
        DrawCacheProjsBehindNPCsAndTiles.Clear();
        DrawCacheProjsBehindNPCs.Clear();
        DrawCacheProjsBehindProjectiles.Clear();
        DrawCacheProjsOverWiresUI.Clear();
        DrawCacheProjsOverPlayers.Clear();
        DrawCacheFirstFractals.Clear();
        for (int i = 0; i < 1000; i++)
        {
            if (!projectile[i].active)
            {
                continue;
            }
            if (projectile[i].type == 857)
            {
                DrawCacheFirstFractals.Add(i);
            }
            if (projectile[i].type == 578 || projectile[i].type == 579 || projectile[i].type == 641 || projectile[i].type == 617 || projectile[i].type == 813)
            {
                DrawCacheProjsBehindNPCsAndTiles.Add(i);
            }
            if (projectile[i].type == 625 || projectile[i].type == 626 || projectile[i].type == 627 || projectile[i].type == 628 || projectile[i].type == 525 || projectile[i].type == 960 || projectile[i].type == 734 || projectile[i].type == 946 || (projectile[i].type == 908 && projectile[i].localAI[0] <= 0f))
            {
                DrawCacheProjsBehindProjectiles.Add(i);
            }
            if (projectile[i].type == 759 || (projectile[i].type == 908 && projectile[i].localAI[0] > 0f))
            {
                DrawCacheProjsOverPlayers.Add(i);
            }
            if (projectile[i].type == 651)
            {
                DrawCacheProjsOverWiresUI.Add(i);
            }
            if (projectile[i].type == 673 || projectile[i].type == 674 || projectile[i].type == 691 || projectile[i].type == 692 || projectile[i].type == 693 || projectile[i].type == 923)
            {
                DrawCacheProjsBehindNPCs.Add(i);
            }
            if (projectile[i].type != 636 && projectile[i].type != 598 && projectile[i].type != 971)
            {
                continue;
            }
            bool flag = true;
            if (projectile[i].ai[0] == 1f)
            {
                int num = (int)projectile[i].ai[1];
                if (num >= 0 && num < 200 && npc[num].active && npc[num].type != 492)
                {
                    if (npc[num].behindTiles)
                    {
                        DrawCacheProjsBehindNPCsAndTiles.Add(i);
                    }
                    else
                    {
                        DrawCacheProjsBehindNPCs.Add(i);
                    }
                    flag = false;
                }
            }
            if (flag)
            {
                DrawCacheProjsBehindProjectiles.Add(i);
            }
        }
    }
 
    protected void DrawCachedNPCs(List<int> npcCache, bool behindTiles)
    {
        for (int i = 0; i < npcCache.Count; i++)
        {
            try
            {
                DrawNPC(npcCache[i], behindTiles);
            }
            catch
            {
                npc[npcCache[i]].active = false;
            }
        }
    }
 
    protected void DrawCachedProjs(List<int> projCache, bool startSpriteBatch = true)
    {
        if (startSpriteBatch)
        {
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        }
        CurrentDrawnEntity = null;
        CurrentDrawnEntityShader = 0;
        for (int i = 0; i < projCache.Count; i++)
        {
            try
            {
                DrawProj(projCache[i]);
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                projectile[projCache[i]].active = false;
            }
        }
        CurrentDrawnEntity = null;
        CurrentDrawnEntityShader = 0;
        if (startSpriteBatch)
        {
            spriteBatch.End();
        }
    }
 
    protected void DrawSuperSpecialProjectiles(List<int> projCache, bool startSpriteBatch = true)
    {
        if (startSpriteBatch)
        {
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        }
        for (int i = 0; i < projCache.Count; i++)
        {
            try
            {
                int num = projCache[i];
                Projectile projectile = Main.projectile[num];
                int owner = projectile.owner;
                Player other = Main.player[owner];
                if (playerVisualClone[owner] == null)
                {
                    playerVisualClone[owner] = new Player();
                }
                Player player = playerVisualClone[owner];
                player.CopyVisuals(other);
                player.isFirstFractalAfterImage = true;
                player.firstFractalAfterImageOpacity = projectile.Opacity * 1f;
                player.ResetEffects();
                player.ResetVisibleAccessories();
                player.UpdateDyes();
                player.DisplayDollUpdate();
                player.UpdateSocialShadow();
                player.itemAnimationMax = 60;
                player.itemAnimation = (int)projectile.localAI[0];
                player.itemRotation = projectile.velocity.ToRotation();
                player.heldProj = num;
                player.Center = projectile.Center - projectile.velocity.SafeNormalize(Vector2.Zero) * 42f;
                player.direction = ((projectile.velocity.X > 0f) ? 1 : (-1));
                player.itemRotation = (float)Math.Atan2(projectile.velocity.Y * (float)player.direction, projectile.velocity.X * (float)player.direction);
                player.velocity.Y = 0.01f;
                player.wingFrame = 2;
                player.PlayerFrame();
                player.socialIgnoreLight = true;
                PlayerRenderer.DrawPlayer(Camera, player, player.position, 0f, player.fullRotationOrigin);
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                Main.projectile[projCache[i]].active = false;
            }
        }
        if (startSpriteBatch)
        {
            spriteBatch.End();
        }
    }
 
    protected void SortDrawCacheWorms()
    {
        SortBabyBirdProjectiles(DrawCacheProjsOverPlayers);
        SortStardustDragonProjectiles(DrawCacheProjsBehindProjectiles);
    }
 
    private void SortBabyBirdProjectiles(List<int> list)
    {
        List<int> list2 = new List<int>();
        for (int num = list.Count - 1; num >= 0; num--)
        {
            int num2 = list[num];
            if (Main.projectile[num2].type == 759)
            {
                list2.Add(num2);
                list.RemoveAt(num);
                Projectile projectile = Main.projectile[num2];
                Player master = player[projectile.owner];
                int stackedIndex = (int)projectile.localAI[0];
                if (projectile.frame == projFrames[projectile.type] - 1)
                {
                    projectile.Center = Projectile.AI_158_GetHomeLocation(master, stackedIndex);
                    projectile.velocity = Vector2.Zero;
                }
            }
        }
        list.AddRange(list2);
        list2.Clear();
    }
 
    private void SortStardustDragonProjectiles(List<int> list)
    {
        List<List<int>> list2 = new List<List<int>>();
        for (int i = 0; i < list.Count; i++)
        {
            int num = list[i];
            if (Main.projectile[num].type == 628)
            {
                list.Remove(num);
                List<int> list3 = new List<int>();
                list3.Insert(0, num);
                int byUUID = Projectile.GetByUUID(Main.projectile[num].owner, Main.projectile[num].ai[0]);
                while (byUUID >= 0 && !list3.Contains(byUUID) && Main.projectile[byUUID].active && Main.projectile[byUUID].type >= 625 && Main.projectile[byUUID].type <= 627)
                {
                    list3.Add(byUUID);
                    list.Remove(byUUID);
                    byUUID = Projectile.GetByUUID(Main.projectile[byUUID].owner, Main.projectile[byUUID].ai[0]);
                }
                List<int> list4 = new List<int>();
                for (int num2 = list3.Count - 2; num2 >= 0; num2--)
                {
                    list4.Add(list3[num2]);
                }
                list4.Add(list3[list3.Count - 1]);
                list2.Add(list4);
                i = -1;
            }
        }
        List<int> list5 = new List<int>(list);
        list2.Add(list5);
        list.Clear();
        for (int j = 0; j < list2.Count; j++)
        {
            for (int k = 0; k < list2[j].Count; k++)
            {
                list.Add(list2[j][k]);
            }
        }
        for (int l = 0; l < list.Count; l++)
        {
            Projectile projectile = Main.projectile[list[l]];
            int byUUID2 = Projectile.GetByUUID(projectile.owner, projectile.ai[0]);
            if (projectile.type < 626 || projectile.type > 628 || byUUID2 < 0 || !ProjectileID.Sets.StardustDragon[Main.projectile[byUUID2].type])
            {
                continue;
            }
            Vector2 vector = Main.projectile[byUUID2].Center - projectile.Center;
            if (vector != Vector2.Zero)
            {
                float num3 = Main.projectile[byUUID2].scale * 16f;
                float num4 = vector.Length();
                float num5 = num3 - num4;
                if (num5 != 0f)
                {
                    projectile.Center += Vector2.Normalize(vector) * (0f - num5);
                }
            }
        }
    }
 
    protected void DrawWoF()
    {
        if (wofNPCIndex < 0 || !npc[wofNPCIndex].active || npc[wofNPCIndex].life <= 0)
        {
            return;
        }
        for (int i = 0; i < 255; i++)
        {
            if (player[i].active && player[i].tongued && !player[i].dead)
            {
                DrawWOFTongueToPlayer(i);
            }
        }
        for (int j = 0; j < 200; j++)
        {
            if (npc[j].active && npc[j].aiStyle == 29)
            {
                DrawWOFRopeToTheHungry(j);
            }
        }
        DrawWOFBody();
    }
 
    private static void DrawWOFBody()
    {
        int num = TextureAssets.Wof.Height() / 3;
        float num2 = wofDrawAreaTop;
        float num3 = wofDrawAreaBottom;
        num3 = screenPosition.Y + (float)screenHeight;
        float num4 = (int)((num2 - screenPosition.Y) / (float)num) + 1;
        if (num4 > 12f)
        {
            return;
        }
        float num5 = num4 * (float)num;
        if (num5 > 0f)
        {
            num2 -= num5;
        }
        float num6 = npc[wofNPCIndex].position.X;
        if (npc[wofNPCIndex].direction > 0)
        {
            num6 -= 80f;
        }
        SpriteEffects effects = SpriteEffects.None;
        if (npc[wofNPCIndex].spriteDirection == 1)
        {
            effects = SpriteEffects.FlipHorizontally;
        }
        int num7 = wofDrawFrameIndex / 6 * num;
        if (!gamePaused && ++wofDrawFrameIndex >= 18)
        {
            wofDrawFrameIndex = 0;
        }
        float num8 = num3 - num2;
        for (int i = (int)num2; (float)i < num3; i += num)
        {
            num8 = num3 - (float)i;
            if (num8 > (float)num)
            {
                num8 = num;
            }
            for (int j = 0; (float)j < num8; j += 16)
            {
                int x = (int)(num6 + (float)(TextureAssets.Wof.Width() / 2)) / 16;
                int y = (i + j) / 16;
                spriteBatch.Draw(TextureAssets.Wof.Value, new Vector2(num6 - screenPosition.X, (float)(i + j) - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, num7 + j, TextureAssets.Wof.Width(), 16), Lighting.GetColor(x, y), 0f, default(Vector2), 1f, effects, 0f);
            }
        }
    }
 
    private static void DrawWOFRopeToTheHungry(int i)
    {
        float num = npc[wofNPCIndex].position.X + (float)(npc[wofNPCIndex].width / 2);
        float y = npc[wofNPCIndex].position.Y;
        float num2 = wofDrawAreaBottom - wofDrawAreaTop;
        bool flag = false;
        if (npc[i].frameCounter > 7.0)
        {
            flag = true;
        }
        y = (float)wofDrawAreaTop + num2 * npc[i].ai[0];
        float scale = npc[i].scale;
        float x = npc[i].Center.X;
        float y2 = npc[i].Bottom.Y - (float)npc[i].height * 0.5f * scale;
        Vector2 vector = new Vector2(x, y2);
        vector += npc[i].netOffset;
        float num3 = num - vector.X;
        float num4 = y - vector.Y;
        float rotation = (float)Math.Atan2(num4, num3) - 1.57f;
        bool flag2 = true;
        while (flag2)
        {
            SpriteEffects effects = SpriteEffects.None;
            if (flag)
            {
                effects = SpriteEffects.FlipHorizontally;
                flag = false;
            }
            else
            {
                flag = true;
            }
            int height = 28;
            int num5 = (int)(40f * scale);
            float num6 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
            if (num6 < (float)num5)
            {
                height = (int)num6 - num5 + 28;
                flag2 = false;
            }
            num6 = 28f * scale / num6;
            num3 *= num6;
            num4 *= num6;
            vector.X += num3;
            vector.Y += num4;
            num3 = num - vector.X;
            num4 = y - vector.Y;
            Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f));
            spriteBatch.Draw(TextureAssets.Chain12.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain4.Width(), height), color, rotation, new Vector2((float)TextureAssets.Chain4.Width() * 0.5f, (float)TextureAssets.Chain4.Height() * 0.5f), scale, effects, 0f);
        }
    }
 
    private static void DrawWOFTongueToPlayer(int i)
    {
        float num = npc[wofNPCIndex].position.X + (float)(npc[wofNPCIndex].width / 2);
        float num2 = npc[wofNPCIndex].position.Y + (float)(npc[wofNPCIndex].height / 2);
        Vector2 vector = new Vector2(player[i].position.X + (float)player[i].width * 0.5f, player[i].position.Y + (float)player[i].height * 0.5f);
        float num3 = num - vector.X;
        float num4 = num2 - vector.Y;
        float rotation = (float)Math.Atan2(num4, num3) - 1.57f;
        bool flag = true;
        while (flag)
        {
            float num5 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
            if (num5 < 40f)
            {
                flag = false;
                continue;
            }
            num5 = (float)TextureAssets.Chain12.Height() / num5;
            num3 *= num5;
            num4 *= num5;
            vector.X += num3;
            vector.Y += num4;
            num3 = num - vector.X;
            num4 = num2 - vector.Y;
            Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)vector.X / 16, (int)(vector.Y / 16f));
            spriteBatch.Draw(TextureAssets.Chain12.Value, new Vector2(vector.X - screenPosition.X, vector.Y - screenPosition.Y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chain12.Width(), TextureAssets.Chain12.Height()), color, rotation, new Vector2((float)TextureAssets.Chain12.Width() * 0.5f, (float)TextureAssets.Chain12.Height() * 0.5f), 1f, SpriteEffects.None, 0f);
        }
    }
 
    public static Microsoft.Xna.Framework.Color quickAlpha(Microsoft.Xna.Framework.Color oldColor, float Alpha)
    {
        Microsoft.Xna.Framework.Color result = oldColor;
        result.R = (byte)((float)(int)result.R * Alpha);
        result.G = (byte)((float)(int)result.G * Alpha);
        result.B = (byte)((float)(int)result.B * Alpha);
        result.A = (byte)((float)(int)result.A * Alpha);
        return result;
    }
 
    private void DrawItem_GetBasics(Item item, int slot, out Texture2D texture, out Microsoft.Xna.Framework.Rectangle frame, out Microsoft.Xna.Framework.Rectangle glowmaskFrame)
    {
        LoadItem(item.type);
        if (ItemID.Sets.AnimatesAsSoul[item.type] || ItemID.Sets.NebulaPickup[item.type])
        {
            DrawItem_AnimateSlot(slot, itemAnimations[item.type].TicksPerFrame, itemAnimations[item.type].FrameCount);
            texture = TextureAssets.Item[item.type].Value;
        }
        else if (ItemID.Sets.IsFood[item.type])
        {
            texture = TextureAssets.Item[item.type].Value;
        }
        else
        {
            switch (item.type)
            {
            case 5358:
            case 5359:
            case 5360:
            case 5361:
                LoadItem(5437);
                texture = TextureAssets.Item[5437].Value;
                break;
            case 71:
            case 72:
            case 73:
            case 74:
            {
                int num = item.type - 71;
                texture = TextureAssets.Coin[num].Value;
                DrawItem_AnimateSlot(slot, 6, 8);
                frame = (glowmaskFrame = _coinOnWorldAnimation.GetFrame(texture, itemFrameCounter[slot]));
                return;
            }
            case 3858:
                texture = TextureAssets.Item[item.type].Value;
                DrawItem_AnimateSlot(slot, 5, 3);
                frame = texture.Frame();
                glowmaskFrame = TextureAssets.GlowMask[233].Value.Frame(1, 3, 0, itemFrameCounter[slot] / 5);
                glowmaskFrame.Height -= 2;
                return;
            case 75:
                texture = TextureAssets.Item[item.type].Value;
                DrawItem_AnimateSlot(slot, itemAnimations[item.type].TicksPerFrame, itemAnimations[item.type].FrameCount * 2 - 1);
                break;
            default:
                texture = TextureAssets.Item[item.type].Value;
                break;
            }
        }
        if (itemAnimations[item.type] != null)
        {
            frame = (glowmaskFrame = itemAnimations[item.type].GetFrame(texture, itemFrameCounter[slot]));
        }
        else
        {
            frame = (glowmaskFrame = texture.Frame());
        }
    }
 
    private void DrawItem_AnimateSlot(int slot, int gameFramesPerSpriteFrame, int spriteFramesAmount)
    {
        if (++itemFrameCounter[slot] >= gameFramesPerSpriteFrame * spriteFramesAmount)
        {
            itemFrameCounter[slot] = 0;
        }
    }
 
    protected void DrawItem(Item item, int whoami)
    {
        if (!item.active || item.IsAir)
        {
            return;
        }
        instance.LoadItem(item.type);
        DrawItem_GetBasics(item, whoami, out var texture, out var frame, out var glowmaskFrame);
        Vector2 vector = frame.Size() / 2f;
        Vector2 vector2 = new Vector2((float)(item.width / 2) - vector.X, item.height - frame.Height);
        Vector2 vector3 = item.position - screenPosition + vector + vector2;
        float num = item.velocity.X * 0.2f;
        if (item.shimmered)
        {
            num = 0f;
        }
        float scale = 1f;
        Microsoft.Xna.Framework.Color color = Lighting.GetColor(item.Center.ToTileCoordinates());
        Microsoft.Xna.Framework.Color currentColor = item.GetAlpha(color);
        if (item.shimmered)
        {
            currentColor.R = (byte)(255f * (1f - item.shimmerTime));
            currentColor.G = (byte)(255f * (1f - item.shimmerTime));
            currentColor.B = (byte)(255f * (1f - item.shimmerTime));
            currentColor.A = (byte)(255f * (1f - item.shimmerTime));
        }
        else if (item.shimmerTime > 0f)
        {
            currentColor.R = (byte)((float)(int)currentColor.R * (1f - item.shimmerTime));
            currentColor.G = (byte)((float)(int)currentColor.G * (1f - item.shimmerTime));
            currentColor.B = (byte)((float)(int)currentColor.B * (1f - item.shimmerTime));
            currentColor.A = (byte)((float)(int)currentColor.A * (1f - item.shimmerTime));
        }
        ItemSlot.GetItemLight(ref currentColor, ref scale, item);
        int num2 = item.glowMask;
        if (!gamePaused && base.IsActive && (item.IsACoin || item.type == 58 || item.type == 109) && color.R > 60 && (float)rand.Next(500) - (Math.Abs(item.velocity.X) + Math.Abs(item.velocity.Y)) * 10f < (float)(color.R / 50))
        {
            int type = 43;
            Microsoft.Xna.Framework.Color newColor = Microsoft.Xna.Framework.Color.White;
            int alpha = 254;
            float scale2 = 0.5f;
            if (item.IsACoin)
            {
                newColor = default(Microsoft.Xna.Framework.Color);
                alpha = 0;
                scale2 = 1f;
            }
            switch (item.type)
            {
            case 71:
                type = 244;
                break;
            case 72:
                type = 245;
                break;
            case 73:
                type = 246;
                break;
            case 74:
                type = 247;
                break;
            }
            int num3 = Dust.NewDust(item.position, item.width, item.height, type, 0f, 0f, alpha, newColor, scale2);
            dust[num3].velocity *= 0f;
        }
        if (ItemID.Sets.BossBag[item.type])
        {
            float num4 = (float)item.timeSinceItemSpawned / 240f + GlobalTimeWrappedHourly * 0.04f;
            float globalTimeWrappedHourly = GlobalTimeWrappedHourly;
            globalTimeWrappedHourly %= 4f;
            globalTimeWrappedHourly /= 2f;
            if (globalTimeWrappedHourly >= 1f)
            {
                globalTimeWrappedHourly = 2f - globalTimeWrappedHourly;
            }
            globalTimeWrappedHourly = globalTimeWrappedHourly * 0.5f + 0.5f;
            for (float num5 = 0f; num5 < 1f; num5 += 0.25f)
            {
                spriteBatch.Draw(texture, vector3 + new Vector2(0f, 8f).RotatedBy((num5 + num4) * ((float)Math.PI * 2f)) * globalTimeWrappedHourly, frame, new Microsoft.Xna.Framework.Color(90, 70, 255, 50), num, vector, scale, SpriteEffects.None, 0f);
            }
            for (float num6 = 0f; num6 < 1f; num6 += 0.34f)
            {
                spriteBatch.Draw(texture, vector3 + new Vector2(0f, 4f).RotatedBy((num6 + num4) * ((float)Math.PI * 2f)) * globalTimeWrappedHourly, frame, new Microsoft.Xna.Framework.Color(140, 120, 255, 77), num, vector, scale, SpriteEffects.None, 0f);
            }
        }
        else if (item.type == 75)
        {
            float num7 = (float)item.timeSinceItemSpawned / 240f + GlobalTimeWrappedHourly * 0.04f;
            float globalTimeWrappedHourly2 = GlobalTimeWrappedHourly;
            globalTimeWrappedHourly2 %= 5f;
            globalTimeWrappedHourly2 /= 2.5f;
            if (globalTimeWrappedHourly2 >= 1f)
            {
                globalTimeWrappedHourly2 = 2f - globalTimeWrappedHourly2;
            }
            globalTimeWrappedHourly2 = globalTimeWrappedHourly2 * 0.5f + 0.5f;
            for (float num8 = 0f; num8 < 1f; num8 += 0.25f)
            {
                spriteBatch.Draw(TextureAssets.Item[item.type].Value, vector3 + new Vector2(0f, 8f).RotatedBy((num8 + num7) * ((float)Math.PI * 2f)) * globalTimeWrappedHourly2, frame, new Microsoft.Xna.Framework.Color(50, 50, 255, 50), num, vector, scale, SpriteEffects.None, 0f);
            }
            for (float num9 = 0f; num9 < 1f; num9 += 0.34f)
            {
                spriteBatch.Draw(TextureAssets.Item[item.type].Value, vector3 + new Vector2(0f, 4f).RotatedBy((num9 + num7) * ((float)Math.PI * 2f)) * globalTimeWrappedHourly2, frame, new Microsoft.Xna.Framework.Color(120, 120, 255, 127), num, vector, scale, SpriteEffects.None, 0f);
            }
        }
        else if (item.type == 4143)
        {
            float num10 = (float)item.timeSinceItemSpawned / 240f + GlobalTimeWrappedHourly * 0.04f;
            float globalTimeWrappedHourly3 = GlobalTimeWrappedHourly;
            globalTimeWrappedHourly3 %= 5f;
            globalTimeWrappedHourly3 /= 2.5f;
            if (globalTimeWrappedHourly3 >= 1f)
            {
                globalTimeWrappedHourly3 = 2f - globalTimeWrappedHourly3;
            }
            globalTimeWrappedHourly3 = globalTimeWrappedHourly3 * 0.5f + 0.5f;
            for (float num11 = 0f; num11 < 1f; num11 += 0.34f)
            {
                spriteBatch.Draw(TextureAssets.Item[item.type].Value, vector3 + new Vector2(0f, 8f).RotatedBy((num11 + num10) * ((float)Math.PI * 2f)) * globalTimeWrappedHourly3, frame, new Microsoft.Xna.Framework.Color(30, 30, 155, 60), num, vector, scale, SpriteEffects.None, 0f);
            }
            for (float num12 = 0f; num12 < 1f; num12 += 0.34f)
            {
                spriteBatch.Draw(TextureAssets.Item[item.type].Value, vector3 + new Vector2(0f, 4f).RotatedBy((num12 + num10) * ((float)Math.PI * 2f)) * globalTimeWrappedHourly3, frame, new Microsoft.Xna.Framework.Color(60, 60, 127, 57), num, vector, scale, SpriteEffects.None, 0f);
            }
            spriteBatch.Draw(texture, vector3, frame, new Microsoft.Xna.Framework.Color(255, 255, 255, 128), num, vector, scale, SpriteEffects.None, 0f);
        }
        if ((item.type >= 1522 && item.type <= 1527) || item.type == 3643)
        {
            currentColor = ((!(item.shimmerTime > 0f)) ? new Microsoft.Xna.Framework.Color(250, 250, 250, mouseTextColor / 2) : new Microsoft.Xna.Framework.Color((int)(250f * (1f - item.shimmerTime)), (int)(250f * (1f - item.shimmerTime)), (int)(250f * (1f - item.shimmerTime)), (int)((float)(mouseTextColor / 2) * (1f - item.shimmerTime))));
            scale = (float)(int)mouseTextColor / 1000f + 0.8f;
        }
        if (item.type == 3779)
        {
            num2 = -1;
        }
        spriteBatch.Draw(texture, vector3, frame, currentColor, num, vector, scale, SpriteEffects.None, 0f);
        if (item.shimmered)
        {
            spriteBatch.Draw(texture, vector3, frame, new Microsoft.Xna.Framework.Color(currentColor.R, currentColor.G, currentColor.B, 0), num, vector, scale, SpriteEffects.None, 0f);
        }
        if (item.color != Microsoft.Xna.Framework.Color.Transparent)
        {
            spriteBatch.Draw(texture, vector3, frame, item.GetColor(color), num, vector, scale, SpriteEffects.None, 0f);
        }
        if (num2 != -1)
        {
            Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(250, 250, 250, item.alpha);
            int type2 = item.type;
            if (type2 == 5146)
            {
                color2 = new Microsoft.Xna.Framework.Color(DiscoR, DiscoG, DiscoB);
            }
            spriteBatch.Draw(TextureAssets.GlowMask[num2].Value, vector3, frame, color2, num, vector, scale, SpriteEffects.None, 0f);
        }
        if (ItemID.Sets.TrapSigned[item.type])
        {
            spriteBatch.Draw(TextureAssets.Wire.Value, vector3 + frame.Size().RotatedBy(num) * 0.45f * item.scale, new Microsoft.Xna.Framework.Rectangle(4, 58, 8, 8), currentColor, 0f, new Vector2(4f), 1f, SpriteEffects.None, 0f);
        }
        if (item.type == 3858)
        {
            spriteBatch.Draw(TextureAssets.GlowMask[233].Value, vector3, glowmaskFrame, new Microsoft.Xna.Framework.Color(255, 255, 255, 63) * 0.75f, num, glowmaskFrame.Size() / 2f, scale, SpriteEffects.None, 0f);
        }
        if (ItemID.Sets.DrawUnsafeIndicator[item.type])
        {
            Vector2 vector4 = new Vector2(-4f, -4f) * scale;
            Texture2D value = TextureAssets.Extra[258].Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame();
            spriteBatch.Draw(value, vector3 + vector4 + frame.Size().RotatedBy(num) * 0.45f * item.scale, rectangle, currentColor, num, rectangle.Size() / 2f, 1f, SpriteEffects.None, 0f);
        }
    }
 
    public void DrawItems()
    {
        for (int i = 0; i < 400; i++)
        {
            DrawItem(item[i], i);
        }
    }
 
    protected void DrawRain()
    {
        bool flag = base.IsActive || netMode == 1;
        Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(0, 0, 2, 40);
        Texture2D value2 = TextureAssets.Rain.Value;
        Vector2 zero = Vector2.Zero;
        for (int i = 0; i < maxRain; i++)
        {
            Rain rain = Main.rain[i];
            if (rain.active)
            {
                value.X = rain.type * 4;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)(rain.position.X + 4f) >> 4, (int)(rain.position.Y + 4f) >> 4) * 0.85f;
                if (shimmerAlpha > 0f)
                {
                    color *= 1f - shimmerAlpha;
                }
                spriteBatch.Draw(value2, rain.position - screenPosition, value, color, rain.rotation, zero, rain.scale, SpriteEffects.None, 0f);
                if (flag)
                {
                    rain.Update();
                }
            }
        }
        TimeLogger.DetailedDrawTime(23);
    }
 
    protected void DrawDust()
    {
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X - 500, (int)screenPosition.Y - 50, screenWidth + 1000, screenHeight + 100);
        rectangle = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X - 1000, (int)screenPosition.Y - 1050, screenWidth + 2000, screenHeight + 2100);
        Microsoft.Xna.Framework.Rectangle rectangle2 = rectangle;
        ArmorShaderData armorShaderData = null;
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullNone, null, Transform);
        for (int i = 0; i < maxDustToDraw; i++)
        {
            Dust dust = Main.dust[i];
            if (!dust.active)
            {
                continue;
            }
            if ((dust.type >= 130 && dust.type <= 134) || (dust.type >= 219 && dust.type <= 223) || dust.type == 226 || dust.type == 278)
            {
                rectangle = rectangle2;
            }
            if (new Microsoft.Xna.Framework.Rectangle((int)dust.position.X, (int)dust.position.Y, 4, 4).Intersects(rectangle))
            {
                float scale = dust.GetVisualScale();
                if (dust.shader != armorShaderData)
                {
                    spriteBatch.End();
                    armorShaderData = dust.shader;
                    if (armorShaderData == null)
                    {
                        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullNone, null, Transform);
                    }
                    else
                    {
                        spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullNone, null, Transform);
                        dust.shader.Apply(null);
                    }
                }
                if (dust.type >= 130 && dust.type <= 134)
                {
                    float num = Math.Abs(dust.velocity.X) + Math.Abs(dust.velocity.Y);
                    num *= 0.3f;
                    num *= 10f;
                    if (num > 10f)
                    {
                        num = 10f;
                    }
                    for (int j = 0; (float)j < num; j++)
                    {
                        Vector2 velocity = dust.velocity;
                        Vector2 vector = dust.position - velocity * j;
                        float scale2 = dust.scale * (1f - (float)j / 10f);
                        Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)((double)dust.position.X + 4.0) / 16, (int)((double)dust.position.Y + 4.0) / 16);
                        color = dust.GetAlpha(color);
                        spriteBatch.Draw(TextureAssets.Dust.Value, vector - screenPosition, dust.frame, color, dust.rotation, new Vector2(4f, 4f), scale2, SpriteEffects.None, 0f);
                    }
                }
                else if (dust.type == 278)
                {
                    float num2 = Math.Abs(dust.velocity.X) + Math.Abs(dust.velocity.Y);
                    num2 *= 0.3f;
                    num2 *= 10f;
                    if (num2 > 10f)
                    {
                        num2 = 10f;
                    }
                    Vector2 origin = new Vector2(4f, 4f);
                    for (int k = 0; (float)k < num2; k++)
                    {
                        Vector2 velocity2 = dust.velocity;
                        Vector2 vector2 = dust.position - velocity2 * k;
                        float scale3 = dust.scale * (1f - (float)k / 10f);
                        Microsoft.Xna.Framework.Color color2 = Lighting.GetColor((int)(dust.position.X + 4f) / 16, (int)(dust.position.Y + 4f) / 16);
                        color2 = dust.GetAlpha(color2);
                        spriteBatch.Draw(TextureAssets.Dust.Value, vector2 - screenPosition, dust.frame, color2, dust.rotation, origin, scale3, SpriteEffects.None, 0f);
                    }
                }
                else if (dust.type >= 219 && dust.type <= 223 && dust.fadeIn == 0f)
                {
                    float num3 = Math.Abs(dust.velocity.X) + Math.Abs(dust.velocity.Y);
                    num3 *= 0.3f;
                    num3 *= 10f;
                    if (num3 > 10f)
                    {
                        num3 = 10f;
                    }
                    for (int l = 0; (float)l < num3; l++)
                    {
                        Vector2 velocity3 = dust.velocity;
                        Vector2 vector3 = dust.position - velocity3 * l;
                        float scale4 = dust.scale * (1f - (float)l / 10f);
                        Microsoft.Xna.Framework.Color color3 = Lighting.GetColor((int)((double)dust.position.X + 4.0) / 16, (int)((double)dust.position.Y + 4.0) / 16);
                        color3 = dust.GetAlpha(color3);
                        spriteBatch.Draw(TextureAssets.Dust.Value, vector3 - screenPosition, dust.frame, color3, dust.rotation, new Vector2(4f, 4f), scale4, SpriteEffects.None, 0f);
                    }
                }
                else if (dust.type == 264 && dust.fadeIn == 0f)
                {
                    float num4 = Math.Abs(dust.velocity.X) + Math.Abs(dust.velocity.Y);
                    num4 *= 10f;
                    if (num4 > 10f)
                    {
                        num4 = 10f;
                    }
                    for (int m = 0; (float)m < num4; m++)
                    {
                        Vector2 velocity4 = dust.velocity;
                        Vector2 vector4 = dust.position - velocity4 * m;
                        float scale5 = dust.scale * (1f - (float)m / 10f);
                        Microsoft.Xna.Framework.Color color4 = Lighting.GetColor((int)((double)dust.position.X + 4.0) / 16, (int)((double)dust.position.Y + 4.0) / 16);
                        color4 = dust.GetAlpha(color4) * 0.3f;
                        spriteBatch.Draw(TextureAssets.Dust.Value, vector4 - screenPosition, dust.frame, color4, dust.rotation, new Vector2(5f), scale5, SpriteEffects.None, 0f);
                        color4 = dust.GetColor(color4);
                        spriteBatch.Draw(TextureAssets.Dust.Value, vector4 - screenPosition, dust.frame, color4, dust.rotation, new Vector2(5f), scale5, SpriteEffects.None, 0f);
                    }
                }
                else if ((dust.type == 226 || dust.type == 272) && dust.fadeIn == 0f)
                {
                    float num5 = Math.Abs(dust.velocity.X) + Math.Abs(dust.velocity.Y);
                    num5 *= 0.3f;
                    num5 *= 10f;
                    if (num5 > 10f)
                    {
                        num5 = 10f;
                    }
                    for (int n = 0; (float)n < num5; n++)
                    {
                        Vector2 velocity5 = dust.velocity;
                        Vector2 vector5 = dust.position - velocity5 * n;
                        float scale6 = dust.scale * (1f - (float)n / 10f);
                        Microsoft.Xna.Framework.Color color5 = Lighting.GetColor((int)((double)dust.position.X + 4.0) / 16, (int)((double)dust.position.Y + 4.0) / 16);
                        color5 = dust.GetAlpha(color5);
                        spriteBatch.Draw(TextureAssets.Dust.Value, vector5 - screenPosition, dust.frame, color5, dust.rotation, new Vector2(4f, 4f), scale6, SpriteEffects.None, 0f);
                    }
                }
                Microsoft.Xna.Framework.Color newColor = Lighting.GetColor((int)((double)dust.position.X + 4.0) / 16, (int)((double)dust.position.Y + 4.0) / 16);
                if (dust.type == 6 || dust.type == 15 || (dust.type >= 59 && dust.type <= 64))
                {
                    newColor = Microsoft.Xna.Framework.Color.White;
                }
                newColor = dust.GetAlpha(newColor);
                if (dust.type == 213)
                {
                    scale = 1f;
                }
                spriteBatch.Draw(TextureAssets.Dust.Value, dust.position - screenPosition, dust.frame, newColor, dust.GetVisualRotation(), new Vector2(4f, 4f), scale, SpriteEffects.None, 0f);
                if (dust.color.PackedValue != 0)
                {
                    Microsoft.Xna.Framework.Color color6 = dust.GetColor(newColor);
                    if (color6.PackedValue != 0)
                    {
                        spriteBatch.Draw(TextureAssets.Dust.Value, dust.position - screenPosition, dust.frame, color6, dust.GetVisualRotation(), new Vector2(4f, 4f), scale, SpriteEffects.None, 0f);
                    }
                }
                if (newColor == Microsoft.Xna.Framework.Color.Black)
                {
                    dust.active = false;
                }
            }
            else
            {
                dust.active = false;
            }
        }
        spriteBatch.End();
        pixelShader.CurrentTechnique.Passes[0].Apply();
        TimeLogger.DetailedDrawTime(25);
    }
 
    private static void HelpText()
    {
        bool flag = false;
        if (player[myPlayer].statLifeMax > 100)
        {
            flag = true;
        }
        bool flag2 = false;
        if (player[myPlayer].statManaMax > 20)
        {
            flag2 = true;
        }
        bool flag3 = true;
        bool flag4 = false;
        bool flag5 = false;
        bool flag6 = false;
        bool flag7 = false;
        bool flag8 = false;
        bool flag9 = false;
        bool flag10 = false;
        bool flag11 = false;
        bool flag12 = false;
        bool flag13 = false;
        for (int i = 0; i < 58; i++)
        {
            if (player[myPlayer].inventory[i].pick > 0 && player[myPlayer].inventory[i].Name != "Copper Pickaxe")
            {
                flag3 = false;
            }
            if (player[myPlayer].inventory[i].axe > 0 && player[myPlayer].inventory[i].Name != "Copper Axe")
            {
                flag3 = false;
            }
            if (player[myPlayer].inventory[i].hammer > 0)
            {
                flag3 = false;
            }
            if (player[myPlayer].inventory[i].type == 11 || player[myPlayer].inventory[i].type == 12 || player[myPlayer].inventory[i].type == 13 || player[myPlayer].inventory[i].type == 14 || player[myPlayer].inventory[i].type == 699 || player[myPlayer].inventory[i].type == 700 || player[myPlayer].inventory[i].type == 701 || player[myPlayer].inventory[i].type == 702)
            {
                flag4 = true;
            }
            if (player[myPlayer].inventory[i].type == 19 || player[myPlayer].inventory[i].type == 20 || player[myPlayer].inventory[i].type == 21 || player[myPlayer].inventory[i].type == 22 || player[myPlayer].inventory[i].type == 703 || player[myPlayer].inventory[i].type == 704 || player[myPlayer].inventory[i].type == 705 || player[myPlayer].inventory[i].type == 706)
            {
                flag5 = true;
            }
            if (player[myPlayer].inventory[i].type == 75)
            {
                flag6 = true;
            }
            if (player[myPlayer].inventory[i].type == 38)
            {
                flag7 = true;
            }
            if (player[myPlayer].inventory[i].type == 68 || player[myPlayer].inventory[i].type == 70 || player[myPlayer].inventory[i].type == 1330 || player[myPlayer].inventory[i].type == 1331 || player[myPlayer].inventory[i].type == 67 || player[myPlayer].inventory[i].type == 2886)
            {
                flag8 = true;
            }
            if (player[myPlayer].inventory[i].type == 84 || player[myPlayer].inventory[i].type == 1236 || player[myPlayer].inventory[i].type == 1237 || player[myPlayer].inventory[i].type == 1238 || player[myPlayer].inventory[i].type == 1239 || player[myPlayer].inventory[i].type == 1240 || player[myPlayer].inventory[i].type == 1241 || player[myPlayer].inventory[i].type == 939 || player[myPlayer].inventory[i].type == 1273 || player[myPlayer].inventory[i].type == 2585 || player[myPlayer].inventory[i].type == 2360 || player[myPlayer].inventory[i].type == 185 || player[myPlayer].inventory[i].type == 1800 || player[myPlayer].inventory[i].type == 1915)
            {
                flag9 = true;
            }
            if (player[myPlayer].inventory[i].type == 3347)
            {
                flag10 = true;
            }
            if (player[myPlayer].inventory[i].type == 174)
            {
                flag11 = true;
            }
            if (player[myPlayer].inventory[i].type == 1141)
            {
                flag12 = true;
            }
            if (player[myPlayer].inventory[i].type == 1533 || player[myPlayer].inventory[i].type == 1534 || player[myPlayer].inventory[i].type == 1535 || player[myPlayer].inventory[i].type == 1536 || player[myPlayer].inventory[i].type == 1537 || player[myPlayer].inventory[i].type == 4714)
            {
                flag13 = true;
            }
        }
        bool flag14 = false;
        bool flag15 = false;
        bool flag16 = false;
        bool flag17 = false;
        bool flag18 = false;
        bool flag19 = false;
        bool flag20 = false;
        bool flag21 = false;
        bool flag22 = false;
        bool flag23 = false;
        bool flag24 = false;
        bool flag25 = false;
        bool flag26 = false;
        bool flag27 = false;
        bool flag28 = false;
        bool flag29 = false;
        bool flag30 = false;
        bool flag31 = false;
        bool flag32 = false;
        bool flag33 = false;
        bool flag34 = false;
        bool flag35 = false;
        bool flag36 = false;
        bool flag37 = false;
        bool flag38 = false;
        int num = 0;
        for (int j = 0; j < 200; j++)
        {
            if (npc[j].active)
            {
                if (npc[j].townNPC && npc[j].type != 37)
                {
                    num++;
                }
                if (npc[j].type == 17)
                {
                    flag14 = true;
                }
                if (npc[j].type == 18)
                {
                    flag15 = true;
                }
                if (npc[j].type == 19)
                {
                    flag17 = true;
                }
                if (npc[j].type == 20)
                {
                    flag16 = true;
                }
                if (npc[j].type == 54)
                {
                    flag22 = true;
                }
                if (npc[j].type == 124)
                {
                    flag19 = true;
                }
                if (npc[j].type == 38)
                {
                    flag18 = true;
                }
                if (npc[j].type == 108)
                {
                    flag20 = true;
                }
                if (npc[j].type == 107)
                {
                    flag21 = true;
                }
                if (npc[j].type == 228)
                {
                    flag23 = true;
                }
                if (npc[j].type == 178)
                {
                    flag24 = true;
                }
                if (npc[j].type == 209)
                {
                    flag25 = true;
                }
                if (npc[j].type == 353)
                {
                    flag26 = true;
                }
                if (npc[j].type == 633)
                {
                    flag38 = true;
                }
                if (npc[j].type == 369)
                {
                    flag27 = true;
                }
                if (npc[j].type == 441)
                {
                    flag28 = true;
                }
                if (npc[j].type == 229)
                {
                    flag29 = true;
                }
                if (npc[j].type == 207)
                {
                    flag30 = true;
                }
                if (npc[j].type == 160)
                {
                    flag31 = true;
                }
                if (npc[j].type == 588)
                {
                    flag32 = true;
                }
                if (npc[j].type == 227)
                {
                    flag33 = true;
                }
                if (npc[j].type == 208)
                {
                    flag34 = true;
                }
                if (npc[j].type == 550)
                {
                    flag35 = true;
                }
                if (npc[j].type == 368)
                {
                    flag36 = true;
                }
                if (npc[j].type == 453)
                {
                    flag37 = true;
                }
            }
        }
        object obj = Lang.CreateDialogSubstitutionObject();
        while (true)
        {
            helpText++;
            if (Language.Exists("GuideHelpText.Help_" + helpText))
            {
                LocalizedText text = Language.GetText("GuideHelpText.Help_" + helpText);
                if (text.CanFormatWith(obj))
                {
                    npcChatText = text.FormatWith(obj);
                    return;
                }
            }
            if (flag3)
            {
                if (helpText == 1)
                {
                    npcChatText = Lang.dialog(177);
                    return;
                }
                if (helpText == 2)
                {
                    npcChatText = Lang.dialog(178);
                    return;
                }
                if (helpText == 3)
                {
                    npcChatText = Lang.dialog(179);
                    return;
                }
                if (helpText == 4)
                {
                    npcChatText = Lang.dialog(180);
                    return;
                }
                if (helpText == 5)
                {
                    npcChatText = Lang.dialog(181);
                    return;
                }
                if (helpText == 6)
                {
                    npcChatText = Lang.dialog(182);
                    return;
                }
            }
            if (flag3 && !flag4 && !flag5 && helpText == 11)
            {
                npcChatText = Lang.dialog(183);
                return;
            }
            if (flag3 && flag4 && !flag5)
            {
                if (helpText == 21)
                {
                    npcChatText = Lang.dialog(184);
                    return;
                }
                if (helpText == 22)
                {
                    npcChatText = Lang.dialog(185);
                    return;
                }
            }
            if (flag3 && flag5)
            {
                if (helpText == 31)
                {
                    npcChatText = Lang.dialog(186);
                    return;
                }
                if (helpText == 32)
                {
                    npcChatText = Lang.dialog(187);
                    return;
                }
            }
            if (!flag && helpText == 41)
            {
                npcChatText = Lang.dialog(188);
                return;
            }
            if (!flag2 && helpText == 42)
            {
                npcChatText = Lang.dialog(189);
                return;
            }
            if (!flag2 && !flag6 && helpText == 43)
            {
                npcChatText = Lang.dialog(190);
                return;
            }
            if (!flag14 && !flag15)
            {
                if (helpText == 51)
                {
                    npcChatText = Lang.dialog(191);
                    return;
                }
                if (helpText == 52)
                {
                    npcChatText = Lang.dialog(192);
                    return;
                }
                if (helpText == 53)
                {
                    npcChatText = Lang.dialog(193);
                    return;
                }
                if (helpText == 54)
                {
                    npcChatText = Lang.dialog(194);
                    return;
                }
                if (helpText == 55)
                {
                    npcChatText = Language.GetTextValue("GuideHelpText.Help_1065");
                    return;
                }
            }
            if (!flag14 && helpText == 61)
            {
                npcChatText = Lang.dialog(195);
                return;
            }
            if (!flag15 && helpText == 62)
            {
                npcChatText = Lang.dialog(196);
                return;
            }
            if (!flag17 && helpText == 63)
            {
                npcChatText = Lang.dialog(197);
                return;
            }
            if (!flag16 && helpText == 64)
            {
                npcChatText = Lang.dialog(198);
                return;
            }
            if (!flag19 && helpText == 65 && NPC.downedBoss3)
            {
                npcChatText = Lang.dialog(199);
                return;
            }
            if (!flag22 && helpText == 66 && NPC.downedBoss3)
            {
                npcChatText = Lang.dialog(200);
                return;
            }
            if (!flag18 && helpText == 67)
            {
                npcChatText = Lang.dialog(201);
                return;
            }
            if (!flag21 && NPC.downedBoss2 && helpText == 68)
            {
                npcChatText = Lang.dialog(202);
                return;
            }
            if (!flag20 && hardMode && helpText == 69)
            {
                npcChatText = Lang.dialog(203);
                return;
            }
            if (!flag23 && helpText == 70 && NPC.downedBoss2)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1100");
                return;
            }
            if (!flag24 && helpText == 71 && hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1101");
                return;
            }
            if (!flag25 && helpText == 72 && NPC.downedMechBoss1 && NPC.downedMechBoss2 && NPC.downedMechBoss3)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1102");
                return;
            }
            if (!flag26 && helpText == 73)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1103");
                return;
            }
            if (!flag27 && helpText == 74)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1104");
                return;
            }
            if (!flag28 && helpText == 75 && hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1105");
                return;
            }
            if (!flag29 && helpText == 76 && hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1106");
                return;
            }
            if (!flag30 && helpText == 77)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1107");
                return;
            }
            if (!flag31 && helpText == 78 && hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1108");
                return;
            }
            if (!flag32 && helpText == 79)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1109");
                return;
            }
            if (!flag33 && helpText == 80 && num >= 5)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1110");
                return;
            }
            if (!flag34 && helpText == 81 && num >= 11)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1111");
                return;
            }
            if (!flag35 && NPC.downedBoss2 && helpText == 82)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1112");
                return;
            }
            if (!flag36 && helpText == 83 && flag14)
            {
                npcChatText = Language.GetTextValueWith("GuideHelpTextSpecific.Help_1113", obj);
                return;
            }
            if (!flag37 && helpText == 84 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1114");
                return;
            }
            if (!flag38 && helpText == 85 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1115");
                return;
            }
            if (flag7 && !WorldGen.crimson && helpText == 100)
            {
                npcChatText = Lang.dialog(204);
                return;
            }
            if (flag8 && helpText == 101)
            {
                npcChatText = Lang.dialog(WorldGen.crimson ? 403 : 205);
                return;
            }
            if ((flag7 || flag8) && helpText == 102)
            {
                npcChatText = Lang.dialog(WorldGen.crimson ? 402 : 206);
                return;
            }
            if (flag7 && WorldGen.crimson && helpText == 103)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1159");
                return;
            }
            if (!flag9 && LocalPlayer.miscEquips[4].IsAir && helpText == 201 && !hardMode && !NPC.downedBoss3 && !NPC.downedBoss2)
            {
                npcChatText = Lang.dialog(207);
                return;
            }
            if (helpText == 202 && !hardMode && player[myPlayer].statLifeMax >= 140)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1120");
                return;
            }
            if (helpText == 203 && hardMode && NPC.downedMechBossAny)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1121");
                return;
            }
            if (helpText == 204 && !NPC.downedGoblins && player[myPlayer].statLifeMax >= 200 && WorldGen.shadowOrbSmashed)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1122");
                return;
            }
            if (helpText == 205 && hardMode && !NPC.downedPirates && player[myPlayer].statLifeMax >= 200)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1123");
                return;
            }
            if (helpText == 206 && hardMode && NPC.downedGolemBoss && !NPC.downedMartians)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1124");
                return;
            }
            if (helpText == 207 && (NPC.downedBoss1 || NPC.downedBoss2 || NPC.downedBoss3))
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1125");
                return;
            }
            if (helpText == 208 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1130");
                return;
            }
            if (helpText == 209 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1131");
                return;
            }
            if (helpText == 210 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1132");
                return;
            }
            if (helpText == 211 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1133");
                return;
            }
            if (helpText == 212 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1134");
                return;
            }
            if (helpText == 213 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1135");
                return;
            }
            if (helpText == 214 && !hardMode && (flag4 || flag5))
            {
                npcChatText = Language.GetTextValueWith("GuideHelpTextSpecific.Help_1136", obj);
                return;
            }
            if (helpText == 215 && LocalPlayer.anglerQuestsFinished < 1)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1137");
                return;
            }
            if (helpText == 216 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1138");
                return;
            }
            if (helpText == 1000 && !NPC.downedBoss1 && !NPC.downedBoss2)
            {
                npcChatText = Lang.dialog(208);
                return;
            }
            if (helpText == 1001 && !NPC.downedBoss1 && !NPC.downedBoss2)
            {
                npcChatText = Lang.dialog(209);
                return;
            }
            if (helpText == 1002 && !NPC.downedBoss2)
            {
                if (WorldGen.crimson)
                {
                    npcChatText = Lang.dialog(331);
                }
                else
                {
                    npcChatText = Lang.dialog(210);
                }
                return;
            }
            if (helpText == 1050 && !NPC.downedBoss1 && player[myPlayer].statLifeMax < 200)
            {
                npcChatText = Lang.dialog(211);
                return;
            }
            if (helpText == 1051 && !NPC.downedBoss1 && player[myPlayer].statDefense <= 10)
            {
                npcChatText = Lang.dialog(212);
                return;
            }
            if (helpText == 1052 && !NPC.downedBoss1 && player[myPlayer].statLifeMax >= 200 && player[myPlayer].statDefense > 10)
            {
                npcChatText = Lang.dialog(WorldGen.crimson ? 404 : 213);
                return;
            }
            if (helpText == 1053 && NPC.downedBoss1 && !NPC.downedBoss2 && player[myPlayer].statLifeMax < 300)
            {
                npcChatText = Lang.dialog(214);
                return;
            }
            if (helpText == 1054 && NPC.downedBoss1 && !NPC.downedBoss2 && !WorldGen.crimson && player[myPlayer].statLifeMax >= 300)
            {
                npcChatText = Lang.dialog(215);
                return;
            }
            if (helpText == 1055 && NPC.downedBoss1 && !NPC.downedBoss2 && !WorldGen.crimson && player[myPlayer].statLifeMax >= 300)
            {
                npcChatText = Lang.dialog(216);
                return;
            }
            if (helpText == 1056 && NPC.downedBoss1 && NPC.downedBoss2 && !NPC.downedBoss3)
            {
                npcChatText = Lang.dialog(217);
                return;
            }
            if (helpText == 1057 && NPC.downedBoss1 && NPC.downedBoss2 && NPC.downedBoss3 && !hardMode && player[myPlayer].statLifeMax < 400)
            {
                npcChatText = Lang.dialog(218);
                return;
            }
            if (helpText == 1058 && NPC.downedBoss1 && NPC.downedBoss2 && NPC.downedBoss3 && !hardMode && player[myPlayer].statLifeMax >= 400)
            {
                npcChatText = Lang.dialog(219);
                return;
            }
            if (helpText == 1059 && NPC.downedBoss1 && NPC.downedBoss2 && NPC.downedBoss3 && !hardMode && player[myPlayer].statLifeMax >= 400)
            {
                npcChatText = Lang.dialog(220);
                return;
            }
            if (helpText == 1060 && NPC.downedBoss1 && NPC.downedBoss2 && NPC.downedBoss3 && !hardMode && player[myPlayer].statLifeMax >= 400)
            {
                npcChatText = Lang.dialog(221);
                return;
            }
            if (helpText == 1061 && hardMode && !NPC.downedPlantBoss)
            {
                npcChatText = Lang.dialog(WorldGen.crimson ? 401 : 222);
                return;
            }
            if (helpText == 1062 && hardMode && !NPC.downedPlantBoss)
            {
                npcChatText = Lang.dialog(223);
                return;
            }
            if (helpText == 1140 && NPC.downedBoss1 && !NPC.downedBoss2 && WorldGen.crimson && player[myPlayer].statLifeMax >= 300)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1140");
                return;
            }
            if (helpText == 1141 && NPC.downedBoss1 && !NPC.downedBoss2 && WorldGen.crimson && player[myPlayer].statLifeMax >= 300)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1141");
                return;
            }
            if (helpText == 1142 && NPC.downedBoss2 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1142");
                return;
            }
            if (helpText == 1143 && NPC.downedBoss2 && !NPC.downedQueenBee && player[myPlayer].statLifeMax >= 300)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1143");
                return;
            }
            if (helpText == 1144 && flag10)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1144");
                return;
            }
            if (helpText == 1145 && flag11 && !hardMode)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1145");
                return;
            }
            if (helpText == 1146 && hardMode && player[myPlayer].wingsLogic == 0 && !LocalPlayer.mount.Active && !NPC.downedPlantBoss)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1146");
                return;
            }
            if (helpText == 1147 && hardMode && WorldGen.SavedOreTiers.Adamantite == 111 && !NPC.downedMechBossAny)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1147");
                return;
            }
            if (helpText == 1148 && hardMode && WorldGen.SavedOreTiers.Adamantite == 223 && !NPC.downedMechBossAny)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1148");
                return;
            }
            if (helpText == 1149 && hardMode && NPC.downedMechBossAny && player[myPlayer].statLifeMax < 500)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1149");
                return;
            }
            if (helpText == 1150 && hardMode && NPC.downedMechBoss1 && NPC.downedMechBoss2 && NPC.downedMechBoss3 && !NPC.downedPlantBoss)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1150");
                return;
            }
            if (helpText == 1151 && hardMode && NPC.downedPlantBoss && !NPC.downedGolemBoss && flag12)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1151");
                return;
            }
            if (helpText == 1152 && hardMode && NPC.downedPlantBoss && !NPC.downedGolemBoss && !flag12)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1152");
                return;
            }
            if (helpText == 1153 && hardMode && flag13)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1153");
                return;
            }
            if (helpText == 1154 && hardMode && !NPC.downedFishron)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1154");
                return;
            }
            if (helpText == 1155 && hardMode && NPC.downedGolemBoss && !NPC.downedHalloweenTree && !NPC.downedHalloweenKing)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1155");
                return;
            }
            if (helpText == 1156 && hardMode && NPC.downedGolemBoss && !NPC.downedChristmasIceQueen && !NPC.downedChristmasTree && !NPC.downedChristmasSantank)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1156");
                return;
            }
            if (helpText == 1157 && hardMode && NPC.downedGolemBoss && NPC.AnyNPCs(437) && !NPC.downedMoonlord)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1157");
                return;
            }
            if (helpText == 1158 && hardMode && NPC.LunarApocalypseIsUp && !NPC.downedMoonlord)
            {
                npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1158");
                return;
            }
            if (helpText == 1159 && NPC.downedBoss1 && NPC.downedBoss2 && !NPC.downedDeerclops)
            {
                break;
            }
            if (helpText > 1200)
            {
                helpText = 0;
            }
        }
        npcChatText = Language.GetTextValue("GuideHelpTextSpecific.Help_1160");
    }
 
    protected void GUIChatDrawInner()
    {
        if (player[myPlayer].talkNPC < 0 && player[myPlayer].sign == -1)
        {
            npcChatText = "";
            return;
        }
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(200, 200, 200, 200);
        int num = (mouseTextColor * 2 + 255) / 3;
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(num, num, num, num);
        bool flag = InGameUI.CurrentState is UIVirtualKeyboard && PlayerInput.UsingGamepad;
        string textValue = npcChatText;
        bool num2 = player[myPlayer].talkNPC != -1 && CanDryadPlayStardewAnimation(LocalPlayer, npc[player[myPlayer].talkNPC]);
        if (player[myPlayer].talkNPC != -1 && npc[player[myPlayer].talkNPC].ai[0] == 24f && NPC.RerollDryadText == 2)
        {
            NPC.RerollDryadText = 1;
        }
        if (num2 && NPC.RerollDryadText == 1 && npc[player[myPlayer].talkNPC].ai[0] != 24f && player[myPlayer].talkNPC != -1 && npc[player[myPlayer].talkNPC].active && npc[player[myPlayer].talkNPC].type == 20)
        {
            NPC.RerollDryadText = 0;
            npcChatText = npc[player[myPlayer].talkNPC].GetChat();
            NPC.PreventJojaColaDialog = true;
        }
        if (num2 && !NPC.PreventJojaColaDialog)
        {
            textValue = Language.GetTextValue("StardewTalk.PlayerHasColaAndIsHoldingIt");
        }
        bool flag2 = player[myPlayer].talkNPC != -1;
        _textDisplayCache.PrepareCache(textValue);
        string[] textLines = _textDisplayCache.TextLines;
        int amountOfLines = _textDisplayCache.AmountOfLines;
        bool flag3 = false;
        if (editSign)
        {
            textBlinkerCount++;
            if (textBlinkerCount >= 20)
            {
                if (textBlinkerState == 0)
                {
                    textBlinkerState = 1;
                }
                else
                {
                    textBlinkerState = 0;
                }
                textBlinkerCount = 0;
            }
            if (textBlinkerState == 1)
            {
                flag3 = true;
            }
            instance.DrawWindowsIMEPanel(new Vector2(screenWidth / 2, 90f), 0.5f);
        }
        amountOfLines++;
        spriteBatch.Draw(TextureAssets.ChatBack.Value, new Vector2(screenWidth / 2 - TextureAssets.ChatBack.Width() / 2, 100f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.ChatBack.Width(), (amountOfLines + 1) * 30), color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        spriteBatch.Draw(TextureAssets.ChatBack.Value, new Vector2(screenWidth / 2 - TextureAssets.ChatBack.Width() / 2, 100 + (amountOfLines + 1) * 30), new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.ChatBack.Height() - 30, TextureAssets.ChatBack.Width(), 30), color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        for (int i = 0; i < amountOfLines; i++)
        {
            string text = textLines[i];
            if (text != null)
            {
                if (i == amountOfLines - 1 && flag3)
                {
                    text += "|";
                }
                if (flag2)
                {
                    ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(170 + (screenWidth - 800) / 2, 120 + i * 30), color2, 0f, Vector2.Zero, Vector2.One);
                }
                else
                {
                    Utils.DrawBorderStringFourWay(spriteBatch, FontAssets.MouseText.Value, text, 170 + (screenWidth - 800) / 2, 120 + i * 30, color2, Microsoft.Xna.Framework.Color.Black, Vector2.Zero);
                }
            }
        }
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(screenWidth / 2 - TextureAssets.ChatBack.Width() / 2, 100, TextureAssets.ChatBack.Width(), (amountOfLines + 2) * 30);
        int num3 = 120 + amountOfLines * 30 + 30;
        num3 -= 235;
        UIVirtualKeyboard.ShouldHideText = !PlayerInput.SettingsForUI.ShowGamepadHints;
        if (!PlayerInput.UsingGamepad)
        {
            num3 = 9999;
        }
        UIVirtualKeyboard.OffsetDown = num3;
        if (npcChatCornerItem != 0)
        {
            Vector2 position = new Vector2(screenWidth / 2 + TextureAssets.ChatBack.Width() / 2, 100 + (amountOfLines + 1) * 30 + 30);
            position -= Vector2.One * 8f;
            Item item = new Item();
            item.netDefaults(npcChatCornerItem);
            float num4 = 1f;
            GetItemDrawFrame(item.type, out var itemTexture, out var rectangle2);
            if (rectangle2.Width > 32 || rectangle2.Height > 32)
            {
                num4 = ((rectangle2.Width <= rectangle2.Height) ? (32f / (float)rectangle2.Height) : (32f / (float)rectangle2.Width));
            }
            spriteBatch.Draw(itemTexture, position, rectangle2, item.GetAlpha(Microsoft.Xna.Framework.Color.White), 0f, rectangle2.Size(), num4, SpriteEffects.None, 0f);
            if (item.color != default(Microsoft.Xna.Framework.Color))
            {
                spriteBatch.Draw(itemTexture, position, rectangle2, item.GetColor(item.color), 0f, rectangle2.Size(), num4, SpriteEffects.None, 0f);
            }
            if (new Microsoft.Xna.Framework.Rectangle((int)position.X - (int)((float)rectangle2.Width * num4), (int)position.Y - (int)((float)rectangle2.Height * num4), (int)((float)rectangle2.Width * num4), (int)((float)rectangle2.Height * num4)).Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)))
            {
                cursorOverride = 2;
                if (mouseLeftRelease && mouseLeft)
                {
                    if (!drawingPlayerChat)
                    {
                        OpenPlayerChat();
                    }
                    if (ChatManager.AddChatText(FontAssets.MouseText.Value, ItemTagHandler.GenerateTag(item), Vector2.One))
                    {
                        SoundEngine.PlaySound(12);
                    }
                }
                MouseText(item.Name, -11, 0);
            }
        }
        num = mouseTextColor;
        color2 = new Microsoft.Xna.Framework.Color(num, (int)((double)num / 1.1), num / 2, num);
        string focusText = "";
        string focusText2 = "";
        int num5 = player[myPlayer].statLifeMax2 - player[myPlayer].statLife;
        for (int j = 0; j < Player.maxBuffs; j++)
        {
            int num6 = player[myPlayer].buffType[j];
            if (debuff[num6] && player[myPlayer].buffTime[j] > 60 && (num6 < 0 || num6 >= BuffID.Count || !BuffID.Sets.NurseCannotRemoveDebuff[num6]))
            {
                num5 += 100;
            }
        }
        if (NPC.downedGolemBoss)
        {
            num5 *= 200;
        }
        else if (NPC.downedPlantBoss)
        {
            num5 *= 150;
        }
        else if (NPC.downedMechBossAny)
        {
            num5 *= 100;
        }
        else if (hardMode)
        {
            num5 *= 60;
        }
        else if (NPC.downedBoss3 || NPC.downedQueenBee)
        {
            num5 *= 25;
        }
        else if (NPC.downedBoss2)
        {
            num5 *= 10;
        }
        else if (NPC.downedBoss1)
        {
            num5 *= 3;
        }
        if (expertMode)
        {
            num5 *= 2;
        }
        num5 = (int)((double)num5 * player[myPlayer].currentShoppingSettings.PriceAdjustment);
        string text2 = null;
        string text3 = null;
        if (player[myPlayer].sign > -1)
        {
            focusText = ((!editSign) ? Lang.inter[48].Value : Lang.inter[47].Value);
        }
        else if (npc[player[myPlayer].talkNPC].type == 20)
        {
            focusText = Lang.inter[28].Value;
            focusText2 = Lang.inter[49].Value;
            if (CanDryadPlayStardewAnimation(LocalPlayer, npc[player[myPlayer].talkNPC]))
            {
                focusText2 = Language.GetTextValue("StardewTalk.GiveColaButtonText");
            }
        }
        else if (NPCID.Sets.IsTownPet[npc[player[myPlayer].talkNPC].type])
        {
            focusText = Language.GetTextValue("UI.PetTheAnimal");
        }
        else if (npc[player[myPlayer].talkNPC].type == 207)
        {
            focusText = Lang.inter[28].Value;
            if (hardMode)
            {
                focusText2 = Lang.inter[107].Value;
            }
        }
        else if (npc[player[myPlayer].talkNPC].type == 453)
        {
            focusText = Lang.inter[28].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 550)
        {
            focusText = Lang.inter[28].Value;
            focusText2 = Language.GetTextValue("UI.BartenderHelp");
        }
        else if (npc[player[myPlayer].talkNPC].type == 588)
        {
            focusText = Lang.inter[28].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 633)
        {
            focusText = Lang.inter[28].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 663)
        {
            focusText = Lang.inter[28].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 353)
        {
            focusText = Lang.inter[28].Value;
            focusText2 = Language.GetTextValue("GameUI.HairStyle");
        }
        else if (npc[player[myPlayer].talkNPC].type == 368)
        {
            focusText = Lang.inter[28].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 369)
        {
            focusText = Lang.inter[64].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 208)
        {
            focusText = Lang.inter[28].Value;
            if (TOWMusicUnlocked)
            {
                focusText2 = Language.GetTextValue("GameUI.Music");
            }
        }
        else if (npc[player[myPlayer].talkNPC].type == 227)
        {
            focusText = Lang.inter[28].Value;
            focusText2 = Language.GetTextValue("GameUI.PainterDecor");
        }
        else if (npc[player[myPlayer].talkNPC].type == 17 || npc[player[myPlayer].talkNPC].type == 19 || npc[player[myPlayer].talkNPC].type == 38 || npc[player[myPlayer].talkNPC].type == 54 || npc[player[myPlayer].talkNPC].type == 107 || npc[player[myPlayer].talkNPC].type == 108 || npc[player[myPlayer].talkNPC].type == 124 || npc[player[myPlayer].talkNPC].type == 142 || npc[player[myPlayer].talkNPC].type == 160 || npc[player[myPlayer].talkNPC].type == 178 || npc[player[myPlayer].talkNPC].type == 207 || npc[player[myPlayer].talkNPC].type == 209 || npc[player[myPlayer].talkNPC].type == 228 || npc[player[myPlayer].talkNPC].type == 229)
        {
            focusText = Lang.inter[28].Value;
            if (npc[player[myPlayer].talkNPC].type == 107)
            {
                focusText2 = Lang.inter[19].Value;
            }
        }
        else if (npc[player[myPlayer].talkNPC].type == 37)
        {
            if (!IsItDay())
            {
                focusText = Lang.inter[50].Value;
            }
        }
        else if (npc[player[myPlayer].talkNPC].type == 22)
        {
            focusText = Lang.inter[51].Value;
            focusText2 = Lang.inter[25].Value;
        }
        else if (npc[player[myPlayer].talkNPC].type == 441)
        {
            if (player[myPlayer].taxMoney <= 0)
            {
                focusText = Lang.inter[89].Value;
            }
            else
            {
                string text4 = "";
                int num7 = 0;
                int num8 = 0;
                int num9 = 0;
                int num10 = 0;
                int taxMoney = player[myPlayer].taxMoney;
                taxMoney = (int)((double)taxMoney / player[myPlayer].currentShoppingSettings.PriceAdjustment);
                if (taxMoney < 0)
                {
                    taxMoney = 0;
                }
                num5 = taxMoney;
                if (taxMoney >= 1000000)
                {
                    num7 = taxMoney / 1000000;
                    taxMoney -= num7 * 1000000;
                }
                if (taxMoney >= 10000)
                {
                    num8 = taxMoney / 10000;
                    taxMoney -= num8 * 10000;
                }
                if (taxMoney >= 100)
                {
                    num9 = taxMoney / 100;
                    taxMoney -= num9 * 100;
                }
                if (taxMoney >= 1)
                {
                    num10 = taxMoney;
                }
                if (num7 > 0)
                {
                    text4 = text4 + num7 + " " + Lang.inter[15].Value + " ";
                }
                if (num8 > 0)
                {
                    text4 = text4 + num8 + " " + Lang.inter[16].Value + " ";
                }
                if (num9 > 0)
                {
                    text4 = text4 + num9 + " " + Lang.inter[17].Value + " ";
                }
                if (num10 > 0)
                {
                    text4 = text4 + num10 + " " + Lang.inter[18].Value + " ";
                }
                float num11 = (float)(int)mouseTextColor / 255f;
                if (num7 > 0)
                {
                    color2 = new Microsoft.Xna.Framework.Color((byte)(220f * num11), (byte)(220f * num11), (byte)(198f * num11), mouseTextColor);
                }
                else if (num8 > 0)
                {
                    color2 = new Microsoft.Xna.Framework.Color((byte)(224f * num11), (byte)(201f * num11), (byte)(92f * num11), mouseTextColor);
                }
                else if (num9 > 0)
                {
                    color2 = new Microsoft.Xna.Framework.Color((byte)(181f * num11), (byte)(192f * num11), (byte)(193f * num11), mouseTextColor);
                }
                else if (num10 > 0)
                {
                    color2 = new Microsoft.Xna.Framework.Color((byte)(246f * num11), (byte)(138f * num11), (byte)(96f * num11), mouseTextColor);
                }
                if (text4 == "")
                {
                    focusText = Lang.inter[89].Value;
                }
                else
                {
                    text4 = text4.Substring(0, text4.Length - 1);
                    focusText = Lang.inter[89].Value + " (" + text4 + ")";
                }
                focusText = Lang.inter[89].Value;
                text3 = focusText;
                text2 = "";
                for (int k = 0; k < focusText.Length; k++)
                {
                    text2 += " ";
                }
                focusText = focusText + text2 + "        ";
            }
        }
        else if (npc[player[myPlayer].talkNPC].type == 18)
        {
            string text5 = "";
            int num12 = 0;
            int num13 = 0;
            int num14 = 0;
            int num15 = 0;
            int num16 = num5;
            if (num16 > 0 && num16 < 1)
            {
                num16 = 1;
            }
            if (num16 < 0)
            {
                num16 = 0;
            }
            num5 = num16;
            if (num16 >= 1000000)
            {
                num12 = num16 / 1000000;
                num16 -= num12 * 1000000;
            }
            if (num16 >= 10000)
            {
                num13 = num16 / 10000;
                num16 -= num13 * 10000;
            }
            if (num16 >= 100)
            {
                num14 = num16 / 100;
                num16 -= num14 * 100;
            }
            if (num16 >= 1)
            {
                num15 = num16;
            }
            if (num12 > 0)
            {
                text5 = text5 + num12 + " " + Lang.inter[15].Value + " ";
            }
            if (num13 > 0)
            {
                text5 = text5 + num13 + " " + Lang.inter[16].Value + " ";
            }
            if (num14 > 0)
            {
                text5 = text5 + num14 + " " + Lang.inter[17].Value + " ";
            }
            if (num15 > 0)
            {
                text5 = text5 + num15 + " " + Lang.inter[18].Value + " ";
            }
            float num17 = (float)(int)mouseTextColor / 255f;
            if (num12 > 0)
            {
                color2 = new Microsoft.Xna.Framework.Color((byte)(220f * num17), (byte)(220f * num17), (byte)(198f * num17), mouseTextColor);
            }
            else if (num13 > 0)
            {
                color2 = new Microsoft.Xna.Framework.Color((byte)(224f * num17), (byte)(201f * num17), (byte)(92f * num17), mouseTextColor);
            }
            else if (num14 > 0)
            {
                color2 = new Microsoft.Xna.Framework.Color((byte)(181f * num17), (byte)(192f * num17), (byte)(193f * num17), mouseTextColor);
            }
            else if (num15 > 0)
            {
                color2 = new Microsoft.Xna.Framework.Color((byte)(246f * num17), (byte)(138f * num17), (byte)(96f * num17), mouseTextColor);
            }
            if (text5 == "")
            {
                focusText = Lang.inter[54].Value;
            }
            else
            {
                text5 = text5.Substring(0, text5.Length - 1);
                focusText = Lang.inter[54].Value + " (" + text5 + ")";
            }
        }
        if (!flag)
        {
            DrawNPCChatButtons(num, color2, amountOfLines, focusText, focusText2);
            if (text2 != null)
            {
                float num18 = 130 + amountOfLines * 30;
                float num19 = 180 + (screenWidth - 800) / 2;
                num19 += ChatManager.GetStringSize(FontAssets.MouseText.Value, text3, new Vector2(0.9f)).X - 20f;
                int taxMoney2 = player[myPlayer].taxMoney;
                taxMoney2 = (int)((double)taxMoney2 / player[myPlayer].currentShoppingSettings.PriceAdjustment);
                ItemSlot.DrawMoney(spriteBatch, "", num19, num18 - 40f, Utils.CoinsSplit(taxMoney2), horizontal: true);
            }
        }
        if (PlayerInput.IgnoreMouseInterface)
        {
            return;
        }
        if (rectangle.Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)))
        {
            player[myPlayer].mouseInterface = true;
        }
        if (!mouseLeft || !mouseLeftRelease || !rectangle.Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)))
        {
            return;
        }
        mouseLeftRelease = false;
        player[myPlayer].releaseUseItem = false;
        player[myPlayer].mouseInterface = true;
        if (npcChatFocus1)
        {
            CloseNPCChatOrSign();
        }
        else if (npcChatFocus2)
        {
            if (player[myPlayer].sign != -1)
            {
                if (editSign)
                {
                    SubmitSignText();
                }
                else
                {
                    IngameFancyUI.OpenVirtualKeyboard(1);
                }
            }
            else if (NPCID.Sets.IsTownPet[npc[player[myPlayer].talkNPC].type])
            {
                player[myPlayer].PetAnimal(player[myPlayer].talkNPC);
            }
            else if (npc[player[myPlayer].talkNPC].type == 369)
            {
                npcChatCornerItem = 0;
                SoundEngine.PlaySound(12);
                bool flag4 = false;
                if (!anglerQuestFinished && !anglerWhoFinishedToday.Contains(player[myPlayer].name))
                {
                    int num20 = player[myPlayer].FindItem(anglerQuestItemNetIDs[anglerQuest]);
                    if (num20 != -1)
                    {
                        player[myPlayer].inventory[num20].stack--;
                        if (player[myPlayer].inventory[num20].stack <= 0)
                        {
                            player[myPlayer].inventory[num20] = new Item();
                        }
                        flag4 = true;
                        SoundEngine.PlaySound(24);
                        player[myPlayer].anglerQuestsFinished++;
                        player[myPlayer].GetAnglerReward(npc[player[myPlayer].talkNPC], anglerQuestItemNetIDs[anglerQuest]);
                    }
                }
                npcChatText = Lang.AnglerQuestChat(flag4);
                if (flag4)
                {
                    anglerQuestFinished = true;
                    if (netMode == 1)
                    {
                        NetMessage.SendData(75);
                    }
                    else
                    {
                        anglerWhoFinishedToday.Add(player[myPlayer].name);
                    }
                    AchievementsHelper.HandleAnglerService();
                }
            }
            else if (npc[player[myPlayer].talkNPC].type == 17)
            {
                OpenShop(1);
            }
            else if (npc[player[myPlayer].talkNPC].type == 19)
            {
                OpenShop(2);
            }
            else if (npc[player[myPlayer].talkNPC].type == 124)
            {
                OpenShop(8);
            }
            else if (npc[player[myPlayer].talkNPC].type == 142)
            {
                OpenShop(9);
            }
            else if (npc[player[myPlayer].talkNPC].type == 37)
            {
                if (netMode == 0)
                {
                    NPC.SpawnSkeletron(myPlayer);
                }
                else
                {
                    NetMessage.SendData(51, -1, -1, null, myPlayer, 1f);
                }
                npcChatText = "";
            }
            else if (npc[player[myPlayer].talkNPC].type == 20)
            {
                OpenShop(3);
            }
            else if (npc[player[myPlayer].talkNPC].type == 38)
            {
                OpenShop(4);
            }
            else if (npc[player[myPlayer].talkNPC].type == 54)
            {
                OpenShop(5);
            }
            else if (npc[player[myPlayer].talkNPC].type == 107)
            {
                OpenShop(6);
            }
            else if (npc[player[myPlayer].talkNPC].type == 108)
            {
                OpenShop(7);
            }
            else if (npc[player[myPlayer].talkNPC].type == 160)
            {
                OpenShop(10);
            }
            else if (npc[player[myPlayer].talkNPC].type == 178)
            {
                OpenShop(11);
            }
            else if (npc[player[myPlayer].talkNPC].type == 207)
            {
                OpenShop(12);
            }
            else if (npc[player[myPlayer].talkNPC].type == 208)
            {
                OpenShop(13);
            }
            else if (npc[player[myPlayer].talkNPC].type == 209)
            {
                OpenShop(14);
            }
            else if (npc[player[myPlayer].talkNPC].type == 227)
            {
                OpenShop(15);
            }
            else if (npc[player[myPlayer].talkNPC].type == 228)
            {
                OpenShop(16);
            }
            else if (npc[player[myPlayer].talkNPC].type == 229)
            {
                OpenShop(17);
            }
            else if (npc[player[myPlayer].talkNPC].type == 353)
            {
                OpenShop(18);
            }
            else if (npc[player[myPlayer].talkNPC].type == 368)
            {
                OpenShop(19);
            }
            else if (npc[player[myPlayer].talkNPC].type == 453)
            {
                OpenShop(20);
            }
            else if (npc[player[myPlayer].talkNPC].type == 550)
            {
                OpenShop(21);
            }
            else if (npc[player[myPlayer].talkNPC].type == 588)
            {
                OpenShop(22);
            }
            else if (npc[player[myPlayer].talkNPC].type == 633)
            {
                OpenShop(23);
            }
            else if (npc[player[myPlayer].talkNPC].type == 663)
            {
                OpenShop(24);
            }
            else if (npc[player[myPlayer].talkNPC].type == 22)
            {
                SoundEngine.PlaySound(12);
                HelpText();
            }
            else if (npc[player[myPlayer].talkNPC].type == 441)
            {
                if (player[myPlayer].taxMoney > 0)
                {
                    int taxMoney3 = player[myPlayer].taxMoney;
                    taxMoney3 = (int)((double)taxMoney3 / player[myPlayer].currentShoppingSettings.PriceAdjustment);
                    while (taxMoney3 > 0)
                    {
                        EntitySource_Gift source = new EntitySource_Gift(npc[player[myPlayer].talkNPC]);
                        if (taxMoney3 > 1000000)
                        {
                            int num21 = taxMoney3 / 1000000;
                            taxMoney3 -= 1000000 * num21;
                            int number = Item.NewItem(source, (int)player[myPlayer].position.X, (int)player[myPlayer].position.Y, player[myPlayer].width, player[myPlayer].height, 74, num21);
                            if (netMode == 1)
                            {
                                NetMessage.SendData(21, -1, -1, null, number, 1f);
                            }
                            continue;
                        }
                        if (taxMoney3 > 10000)
                        {
                            int num22 = taxMoney3 / 10000;
                            taxMoney3 -= 10000 * num22;
                            int number2 = Item.NewItem(source, (int)player[myPlayer].position.X, (int)player[myPlayer].position.Y, player[myPlayer].width, player[myPlayer].height, 73, num22);
                            if (netMode == 1)
                            {
                                NetMessage.SendData(21, -1, -1, null, number2, 1f);
                            }
                            continue;
                        }
                        if (taxMoney3 > 100)
                        {
                            int num23 = taxMoney3 / 100;
                            taxMoney3 -= 100 * num23;
                            int number3 = Item.NewItem(source, (int)player[myPlayer].position.X, (int)player[myPlayer].position.Y, player[myPlayer].width, player[myPlayer].height, 72, num23);
                            if (netMode == 1)
                            {
                                NetMessage.SendData(21, -1, -1, null, number3, 1f);
                            }
                            continue;
                        }
                        int num24 = taxMoney3;
                        if (num24 < 1)
                        {
                            num24 = 1;
                        }
                        taxMoney3 -= num24;
                        int number4 = Item.NewItem(source, (int)player[myPlayer].position.X, (int)player[myPlayer].position.Y, player[myPlayer].width, player[myPlayer].height, 71, num24);
                        if (netMode == 1)
                        {
                            NetMessage.SendData(21, -1, -1, null, number4, 1f);
                        }
                    }
                    npcChatText = Lang.dialog(rand.Next(380, 382));
                    player[myPlayer].taxMoney = 0;
                }
                else
                {
                    npcChatText = Lang.dialog(rand.Next(390, 401));
                }
            }
            else
            {
                if (npc[player[myPlayer].talkNPC].type != 18)
                {
                    return;
                }
                SoundEngine.PlaySound(12);
                if (num5 > 0)
                {
                    if (player[myPlayer].BuyItem(num5))
                    {
                        AchievementsHelper.HandleNurseService(num5);
                        SoundEngine.PlaySound(SoundID.Item4);
                        player[myPlayer].HealEffect(player[myPlayer].statLifeMax2 - player[myPlayer].statLife);
                        if ((double)player[myPlayer].statLife < (double)player[myPlayer].statLifeMax2 * 0.25)
                        {
                            npcChatText = Lang.dialog(227);
                        }
                        else if ((double)player[myPlayer].statLife < (double)player[myPlayer].statLifeMax2 * 0.5)
                        {
                            npcChatText = Lang.dialog(228);
                        }
                        else if ((double)player[myPlayer].statLife < (double)player[myPlayer].statLifeMax2 * 0.75)
                        {
                            npcChatText = Lang.dialog(229);
                        }
                        else
                        {
                            npcChatText = Lang.dialog(230);
                        }
                        player[myPlayer].statLife = player[myPlayer].statLifeMax2;
                        for (int l = 0; l < Player.maxBuffs; l++)
                        {
                            int num25 = player[myPlayer].buffType[l];
                            if (debuff[num25] && player[myPlayer].buffTime[l] > 0 && (num25 < 0 || num25 >= BuffID.Count || !BuffID.Sets.NurseCannotRemoveDebuff[num25]))
                            {
                                player[myPlayer].DelBuff(l);
                                l = -1;
                            }
                        }
                    }
                    else
                    {
                        int num26 = rand.Next(3);
                        if (num26 == 0)
                        {
                            npcChatText = Lang.dialog(52);
                        }
                        if (num26 == 1)
                        {
                            npcChatText = Lang.dialog(53);
                        }
                        if (num26 == 2)
                        {
                            npcChatText = Lang.dialog(54);
                        }
                    }
                }
                else
                {
                    int num27 = rand.Next(3);
                    if (!ChildSafety.Disabled)
                    {
                        num27 = rand.Next(1, 3);
                    }
                    switch (num27)
                    {
                    case 0:
                        npcChatText = Lang.dialog(55);
                        break;
                    case 1:
                        npcChatText = Lang.dialog(56);
                        break;
                    case 2:
                        npcChatText = Lang.dialog(57);
                        break;
                    }
                }
            }
        }
        else if (npcChatFocus4)
        {
            npcChatCornerItem = 0;
            SoundEngine.PlaySound(12);
            npcChatText = player[myPlayer].currentShoppingSettings.HappinessReport;
        }
        else
        {
            if (!npcChatFocus3 || player[myPlayer].talkNPC < 0)
            {
                return;
            }
            if (npc[player[myPlayer].talkNPC].type == 20)
            {
                SoundEngine.PlaySound(12);
                npcChatText = Lang.GetDryadWorldStatusDialog(out var worldIsEntirelyPure);
                if (CanDryadPlayStardewAnimation(LocalPlayer, npc[player[myPlayer].talkNPC]))
                {
                    NPC.PreventJojaColaDialog = true;
                    NPC.RerollDryadText = 2;
                    LocalPlayer.ConsumeItem(5275, reverseOrder: true);
                    if (netMode == 1)
                    {
                        NetMessage.SendData(144);
                    }
                    else
                    {
                        NPC.HaveDryadDoStardewAnimation();
                    }
                    npcChatText = Language.GetTextValue("StardewTalk.PlayerGivesCola");
                }
                else if (worldIsEntirelyPure)
                {
                    AchievementsHelper.HandleSpecialEvent(player[myPlayer], 27);
                }
            }
            if (npc[player[myPlayer].talkNPC].type == 208)
            {
                SoundEngine.PlaySound(12);
                int num28 = rand.Next(1, 4);
                npcChatText = Language.GetTextValue("PartyGirlSpecialText.Music" + num28);
                swapMusic = !swapMusic;
            }
            else if (npc[player[myPlayer].talkNPC].type == 22)
            {
                playerInventory = true;
                npcChatText = "";
                SoundEngine.PlaySound(12);
                InGuideCraftMenu = true;
                UILinkPointNavigator.GoToDefaultPage();
            }
            else if (npc[player[myPlayer].talkNPC].type == 107)
            {
                playerInventory = true;
                npcChatText = "";
                SoundEngine.PlaySound(12);
                InReforgeMenu = true;
                UILinkPointNavigator.GoToDefaultPage();
            }
            else if (npc[player[myPlayer].talkNPC].type == 353)
            {
                OpenHairWindow();
            }
            else if (npc[player[myPlayer].talkNPC].type == 207)
            {
                npcChatCornerItem = 0;
                SoundEngine.PlaySound(12);
                bool gotDye = false;
                int num29 = player[myPlayer].FindItem(ItemID.Sets.ExoticPlantsForDyeTrade);
                if (num29 != -1)
                {
                    player[myPlayer].inventory[num29].stack--;
                    if (player[myPlayer].inventory[num29].stack <= 0)
                    {
                        player[myPlayer].inventory[num29] = new Item();
                    }
                    gotDye = true;
                    SoundEngine.PlaySound(24);
                    player[myPlayer].GetDyeTraderReward(npc[player[myPlayer].talkNPC]);
                }
                npcChatText = Lang.DyeTraderQuestChat(gotDye);
            }
            else if (npc[player[myPlayer].talkNPC].type == 550)
            {
                SoundEngine.PlaySound(12);
                HelpText();
                npcChatText = Lang.BartenderHelpText(npc[player[myPlayer].talkNPC]);
            }
            else if (npc[player[myPlayer].talkNPC].type == 227)
            {
                OpenShop(25);
            }
        }
    }
 
    public static bool CanDryadPlayStardewAnimation(Player player, NPC npc)
    {
        Item heldItem = player.HeldItem;
        if (!heldItem.IsAir && heldItem.type == 5275)
        {
            return npc.ai[0] != 24f;
        }
        return false;
    }
 
    private void OpenShop(int shopIndex)
    {
        playerInventory = true;
        stackSplit = 9999;
        npcChatText = "";
        SetNPCShopIndex(shopIndex);
        shop[npcShop].SetupShop(npcShop);
        SoundEngine.PlaySound(12);
    }
 
    public static void SetNPCShopIndex(int index)
    {
        npcShop = index;
    }
 
    private static void DrawNPCChatButtons(int superColor, Microsoft.Xna.Framework.Color chatColor, int numLines, string focusText, string focusText3)
    {
        float y = 130 + numLines * 30;
        int num = 180 + (screenWidth - 800) / 2;
        Vector2 vec = new Vector2(mouseX, mouseY);
        Player player = Main.player[myPlayer];
        Vector2 vector = new Vector2(num, y);
        string text = focusText;
        DynamicSpriteFont value = FontAssets.MouseText.Value;
        Vector2 vector2 = vector;
        Vector2 vector3 = new Vector2(0.9f);
        Vector2 stringSize = ChatManager.GetStringSize(value, text, vector3);
        Microsoft.Xna.Framework.Color baseColor = chatColor;
        Microsoft.Xna.Framework.Color black = Microsoft.Xna.Framework.Color.Black;
        Vector2 vector4 = new Vector2(1f);
        Microsoft.Xna.Framework.Color brown = Microsoft.Xna.Framework.Color.Brown;
        float num2 = 1.2f;
        if (stringSize.X > 260f)
        {
            vector4.X *= 260f / stringSize.X;
        }
        if (vec.Between(vector2, vector2 + stringSize * vector3 * vector4.X) && !PlayerInput.IgnoreMouseInterface)
        {
            player.mouseInterface = true;
            player.releaseUseItem = false;
            vector3 *= num2;
            if (!npcChatFocus2)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus2 = true;
        }
        else
        {
            if (npcChatFocus2)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus2 = false;
        }
        ChatManager.DrawColorCodedStringShadow(baseColor: (!npcChatFocus2) ? Microsoft.Xna.Framework.Color.Black : brown, spriteBatch: spriteBatch, font: value, text: text, position: vector2 + stringSize * vector4 * 0.5f, rotation: 0f, origin: stringSize * 0.5f, baseScale: vector3 * vector4);
        ChatManager.DrawColorCodedString(spriteBatch, value, text, vector2 + stringSize * vector4 * 0.5f, baseColor, 0f, stringSize * 0.5f, vector3 * vector4);
        if (text.Length > 0)
        {
            UILinkPointNavigator.SetPosition(2500, vector2 + stringSize * 0.5f);
            UILinkPointNavigator.Shortcuts.NPCCHAT_ButtonsLeft = true;
        }
        Vector2 vector5 = new Vector2((float)num + stringSize.X * vector4.X + 30f, y);
        text = Lang.inter[52].Value;
        value = FontAssets.MouseText.Value;
        vector2 = vector5;
        vector3 = new Vector2(0.9f);
        stringSize = ChatManager.GetStringSize(value, text, vector3);
        baseColor = new Microsoft.Xna.Framework.Color(superColor, (int)((double)superColor / 1.1), superColor / 2, superColor);
        vector4 = new Vector2(1f);
        if (vec.Between(vector2, vector2 + stringSize * vector3 * vector4.X) && !PlayerInput.IgnoreMouseInterface)
        {
            player.mouseInterface = true;
            player.releaseUseItem = false;
            vector3 *= num2;
            if (!npcChatFocus1)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus1 = true;
        }
        else
        {
            if (npcChatFocus1)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus1 = false;
        }
        ChatManager.DrawColorCodedStringShadow(baseColor: (!npcChatFocus1) ? Microsoft.Xna.Framework.Color.Black : brown, spriteBatch: spriteBatch, font: value, text: text, position: vector2 + stringSize * vector4 * 0.5f, rotation: 0f, origin: stringSize * 0.5f, baseScale: vector3 * vector4);
        ChatManager.DrawColorCodedString(spriteBatch, value, text, vector2 + stringSize * vector4 * 0.5f, baseColor, 0f, stringSize * 0.5f, vector3 * vector4);
        if (text.Length > 0)
        {
            UILinkPointNavigator.SetPosition(2501, vector2 + stringSize * 0.5f);
            UILinkPointNavigator.Shortcuts.NPCCHAT_ButtonsMiddle = true;
        }
        if (string.IsNullOrWhiteSpace(focusText3))
        {
            npcChatFocus3 = false;
            UILinkPointNavigator.Shortcuts.NPCCHAT_ButtonsRight = false;
        }
        else
        {
            Vector2 vector6 = new Vector2(vector5.X + stringSize.X * vector4.X + 30f, y);
            text = focusText3;
            value = FontAssets.MouseText.Value;
            vector2 = vector6;
            vector3 = new Vector2(0.9f);
            stringSize = ChatManager.GetStringSize(value, text, vector3);
            baseColor = chatColor;
            vector4 = new Vector2(1f);
            vector5.X = vector6.X;
            if (vec.Between(vector2, vector2 + stringSize * vector3 * vector4.X) && !PlayerInput.IgnoreMouseInterface)
            {
                player.mouseInterface = true;
                player.releaseUseItem = false;
                vector3 *= num2;
                if (!npcChatFocus3)
                {
                    SoundEngine.PlaySound(12);
                }
                npcChatFocus3 = true;
            }
            else
            {
                if (npcChatFocus3)
                {
                    SoundEngine.PlaySound(12);
                }
                npcChatFocus3 = false;
            }
            ChatManager.DrawColorCodedStringShadow(baseColor: (!npcChatFocus3) ? Microsoft.Xna.Framework.Color.Black : brown, spriteBatch: spriteBatch, font: value, text: text, position: vector2 + stringSize * vector4 * 0.5f, rotation: 0f, origin: stringSize * 0.5f, baseScale: vector3 * vector4);
            ChatManager.DrawColorCodedString(spriteBatch, value, text, vector2 + stringSize * vector4 * 0.5f, baseColor, 0f, stringSize * 0.5f, vector3 * vector4);
            UILinkPointNavigator.SetPosition(2502, vector2 + stringSize * 0.5f);
            UILinkPointNavigator.Shortcuts.NPCCHAT_ButtonsRight = true;
        }
        if (remixWorld)
        {
            return;
        }
        if (Main.player[myPlayer].currentShoppingSettings.HappinessReport == "")
        {
            npcChatFocus4 = false;
            UILinkPointNavigator.Shortcuts.NPCCHAT_ButtonsRight2 = false;
            return;
        }
        string textValue = Language.GetTextValue("UI.NPCCheckHappiness");
        Vector2 vector7 = new Vector2(vector5.X + stringSize.X * vector4.X + 30f, y);
        text = textValue;
        value = FontAssets.MouseText.Value;
        vector2 = vector7;
        vector3 = new Vector2(0.9f);
        stringSize = ChatManager.GetStringSize(value, text, vector3);
        baseColor = new Microsoft.Xna.Framework.Color(superColor, (int)((double)superColor / 1.1), superColor / 2, superColor);
        vector4 = new Vector2(1f);
        if (vec.Between(vector2, vector2 + stringSize * vector3 * vector4.X) && !PlayerInput.IgnoreMouseInterface)
        {
            player.mouseInterface = true;
            player.releaseUseItem = false;
            vector3 *= num2;
            if (!npcChatFocus4)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus4 = true;
        }
        else
        {
            if (npcChatFocus4)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus4 = false;
        }
        ChatManager.DrawColorCodedStringShadow(baseColor: (!npcChatFocus4) ? Microsoft.Xna.Framework.Color.Black : brown, spriteBatch: spriteBatch, font: value, text: text, position: vector2 + stringSize * vector4 * 0.5f, rotation: 0f, origin: stringSize * 0.5f, baseScale: vector3 * vector4);
        ChatManager.DrawColorCodedString(spriteBatch, value, text, vector2 + stringSize * vector4 * 0.5f, baseColor, 0f, stringSize * 0.5f, vector3 * vector4);
        UILinkPointNavigator.SetPosition(2503, vector2 + stringSize * 0.5f);
        UILinkPointNavigator.Shortcuts.NPCCHAT_ButtonsRight2 = true;
    }
 
    public static void CloseNPCChatOrSign()
    {
        player[myPlayer].sign = -1;
        editSign = false;
        player[myPlayer].SetTalkNPC(-1);
        npcChatCornerItem = 0;
        npcChatText = "";
        SoundEngine.PlaySound(11);
        player[myPlayer].releaseMount = false;
    }
 
    public static void SubmitSignText()
    {
        SoundEngine.PlaySound(12);
        int num = player[myPlayer].sign;
        Sign.TextSign(num, npcChatText);
        editSign = false;
        if (netMode == 1)
        {
            NetMessage.SendData(47, -1, -1, null, num);
        }
    }
 
    private int NPCBannerSorter(int npcIndex1, int npcIndex2)
    {
        return -npc[npcIndex1].housingCategory.CompareTo(npc[npcIndex2].housingCategory);
    }
 
    protected void DrawNPCHousesInWorld()
    {
        _npcsWithBannersToDraw.Clear();
        _occupantsListToDrawNPCHouses.Clear();
        for (int i = 0; i < 200; i++)
        {
            if (npc[i].active && npc[i].townNPC && !npc[i].homeless && npc[i].homeTileX > 0 && npc[i].homeTileY > 0 && npc[i].type != 37)
            {
                _npcsWithBannersToDraw.Add(i);
            }
        }
        _npcsWithBannersToDraw.Sort(NPCBannerSorter);
        for (int j = 0; j < _npcsWithBannersToDraw.Count; j++)
        {
            int num = _npcsWithBannersToDraw[j];
            NPC nPC = npc[num];
            if (!nPC.active || !nPC.townNPC || nPC.homeless || nPC.homeTileX <= 0 || nPC.homeTileY <= 0 || nPC.type == 37)
            {
                continue;
            }
            int num2 = 0;
            int housingCategory = nPC.housingCategory;
            int homeTileX = nPC.homeTileX;
            int num3 = nPC.homeTileY - 1;
            WorldGen.TownManager.AddOccupantsToList(homeTileX, num3 + 1, _occupantsListToDrawNPCHouses);
            if (_occupantsListToDrawNPCHouses.Contains(nPC.type))
            {
                num2 = 1;
            }
            int num4 = 0;
            for (int num5 = _npcsWithBannersToDraw.Count - 1; num5 > j; num5--)
            {
                int num6 = _npcsWithBannersToDraw[num5];
                if (npc[num6].homeTileX == homeTileX && npc[num6].homeTileY == num3 + 1)
                {
                    num4++;
                }
            }
            int num7 = num4 * 26;
            if (tile[homeTileX, num3] == null)
            {
                continue;
            }
            bool flag = false;
            while (!tile[homeTileX, num3].active() || !tileSolid[tile[homeTileX, num3].type])
            {
                num3--;
                if (num3 < 10)
                {
                    break;
                }
                if (tile[homeTileX, num3] == null)
                {
                    flag = true;
                    break;
                }
            }
            if (flag)
            {
                continue;
            }
            int num8 = 8;
            int num9 = 18;
            if (tile[homeTileX, num3].type == 19)
            {
                num9 -= 8;
            }
            num3++;
            int num10 = 0;
            float num11 = num3 * 16;
            num11 += (float)num7;
            SpriteEffects effects = SpriteEffects.None;
            Texture2D value = TextureAssets.HouseBanner.Value;
            Microsoft.Xna.Framework.Rectangle value2 = value.Frame(2, 2);
            if (num2 > 0)
            {
                value2.X += value2.Width * num2;
            }
            if (housingCategory > 0)
            {
                value2.Y += value2.Height * housingCategory;
            }
            if (player[myPlayer].gravDir == -1f)
            {
                num11 -= screenPosition.Y;
                num11 = screenPosition.Y + (float)screenHeight - num11;
                num11 -= (float)value2.Height;
                effects = SpriteEffects.FlipVertically;
                num10 = 4;
            }
            spriteBatch.Draw(value, new Vector2(homeTileX * 16 - (int)screenPosition.X + num8, num11 - (float)(int)screenPosition.Y + (float)num9 + (float)num10), value2, Lighting.GetColor(homeTileX, num3), 0f, new Vector2(value2.Width / 2, value2.Height / 2), 1f, effects, 0f);
            int headIndexSafe = TownNPCProfiles.GetHeadIndexSafe(nPC);
            float scale = 1f;
            float num12 = 0f;
            num12 = ((TextureAssets.NpcHead[headIndexSafe].Width() <= TextureAssets.NpcHead[headIndexSafe].Height()) ? ((float)TextureAssets.NpcHead[headIndexSafe].Height()) : ((float)TextureAssets.NpcHead[headIndexSafe].Width()));
            if (num12 > 24f)
            {
                scale = 24f / num12;
            }
            spriteBatch.Draw(TextureAssets.NpcHead[headIndexSafe].Value, new Vector2(homeTileX * 16 - (int)screenPosition.X + num8, num11 - (float)(int)screenPosition.Y + (float)num9 + 2f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.NpcHead[headIndexSafe].Width(), TextureAssets.NpcHead[headIndexSafe].Height()), Lighting.GetColor(homeTileX, num3), 0f, new Vector2(TextureAssets.NpcHead[headIndexSafe].Width() / 2, TextureAssets.NpcHead[headIndexSafe].Height() / 2), scale, effects, 0f);
            homeTileX = homeTileX * 16 - (int)screenPosition.X + num8 - value2.Width / 2;
            num3 = (int)num11 - (int)screenPosition.Y + 4;
            int num13 = -8;
            if (mouseX >= homeTileX && mouseX <= homeTileX + value2.Width && mouseY >= num3 && mouseY <= num3 + value2.Height + num13)
            {
                string nPCHouseBannerText = Lang.GetNPCHouseBannerText(nPC, num2);
                MouseText(nPCHouseBannerText, 0, 0);
                if (mouseRightRelease && mouseRight)
                {
                    mouseRightRelease = false;
                    WorldGen.kickOut(num);
                    SoundEngine.PlaySound(12);
                }
            }
        }
    }
 
    public void DrawWindowsIMEPanel(Vector2 position, float xAnchor = 0f)
    {
        if (!Platform.Get<IImeService>().IsCandidateListVisible)
        {
            return;
        }
        List<string> list = new List<string>();
        for (uint num = 0u; num < Platform.Get<IImeService>().CandidateCount; num++)
        {
            string candidate = Platform.Get<IImeService>().GetCandidate(num);
            list.Add(candidate);
        }
        if (list.Count == 0)
        {
            return;
        }
        uint selectedCandidate = Platform.Get<IImeService>().SelectedCandidate;
        DynamicSpriteFont value = FontAssets.MouseText.Value;
        float num2 = 0.85f;
        float num3 = 14f;
        float num4 = 0f;
        int num5 = 32;
        num4 += num3;
        string text = "{0,2}: {1}";
        string text2 = "  ";
        for (int i = 0; i < list.Count; i++)
        {
            int num6 = i + 1;
            string text3 = text;
            if (i < list.Count - 1)
            {
                text3 += text2;
            }
            num4 += value.MeasureString(string.Format(text3, num6, list[i])).X * num2;
            num4 += num3;
        }
        Vector2 vector = new Vector2(num4 * (0f - xAnchor), 0f);
        Utils.DrawSettings2Panel(spriteBatch, position + vector + new Vector2(0f, -num5), num4, new Microsoft.Xna.Framework.Color(63, 65, 151, 255) * 0.785f);
        Vector2 pos = position + new Vector2(10f, -num5 / 2) + vector;
        for (uint num7 = 0u; num7 < list.Count; num7++)
        {
            Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Gray;
            if (num7 == selectedCandidate)
            {
                color = Microsoft.Xna.Framework.Color.White;
            }
            uint num8 = num7 + 1;
            string text4 = text;
            if (num7 < list.Count - 1)
            {
                text4 += text2;
            }
            string text5 = string.Format(text4, num8, list[(int)num7]);
            Vector2 vector2 = value.MeasureString(text5) * num2;
            Utils.DrawBorderString(spriteBatch, text5, pos, color, num2, 0f, 0.4f);
            pos.X += vector2.X + num3;
        }
    }
 
    public void HandleIME()
    {
        if (_imeToggle != PlayerInput.WritingText)
        {
            _imeToggle = PlayerInput.WritingText;
            if (_imeToggle)
            {
                Platform.Get<IImeService>().Enable();
            }
            else
            {
                Platform.Get<IImeService>().Disable();
            }
        }
    }
 
    protected void DrawPlayerChat()
    {
        TextSnippet[] array = null;
        if (drawingPlayerChat)
        {
            PlayerInput.WritingText = true;
        }
        HandleIME();
        if (drawingPlayerChat)
        {
            textBlinkerCount++;
            if (textBlinkerCount >= 20)
            {
                if (textBlinkerState == 0)
                {
                    textBlinkerState = 1;
                }
                else
                {
                    textBlinkerState = 0;
                }
                textBlinkerCount = 0;
            }
            string text = chatText;
            if (screenWidth > 800)
            {
                int num = screenWidth - 300;
                int num2 = 78;
                spriteBatch.Draw(TextureAssets.TextBack.Value, new Vector2(num2, screenHeight - 36), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.TextBack.Width() - 100, TextureAssets.TextBack.Height()), new Microsoft.Xna.Framework.Color(100, 100, 100, 100), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                num -= 400;
                num2 += 400;
                while (num > 0)
                {
                    if (num > 300)
                    {
                        spriteBatch.Draw(TextureAssets.TextBack.Value, new Vector2(num2, screenHeight - 36), new Microsoft.Xna.Framework.Rectangle(100, 0, TextureAssets.TextBack.Width() - 200, TextureAssets.TextBack.Height()), new Microsoft.Xna.Framework.Color(100, 100, 100, 100), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        num -= 300;
                        num2 += 300;
                    }
                    else
                    {
                        spriteBatch.Draw(TextureAssets.TextBack.Value, new Vector2(num2, screenHeight - 36), new Microsoft.Xna.Framework.Rectangle(TextureAssets.TextBack.Width() - num, 0, TextureAssets.TextBack.Width() - (TextureAssets.TextBack.Width() - num), TextureAssets.TextBack.Height()), new Microsoft.Xna.Framework.Color(100, 100, 100, 100), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        num = 0;
                    }
                }
            }
            else
            {
                spriteBatch.Draw(TextureAssets.TextBack.Value, new Vector2(78f, screenHeight - 36), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.TextBack.Width(), TextureAssets.TextBack.Height()), new Microsoft.Xna.Framework.Color(100, 100, 100, 100), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            int hoveredSnippet = -1;
            List<TextSnippet> list = ChatManager.ParseMessage(text, Microsoft.Xna.Framework.Color.White);
            string compositionString = Platform.Get<IImeService>().CompositionString;
            if (compositionString != null && compositionString.Length > 0)
            {
                list.Add(new TextSnippet(compositionString, new Microsoft.Xna.Framework.Color(255, 240, 20)));
            }
            if (textBlinkerState == 1)
            {
                list.Add(new TextSnippet("|", Microsoft.Xna.Framework.Color.White));
            }
            array = list.ToArray();
            ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, array, new Vector2(88f, screenHeight - 30), 0f, Vector2.Zero, Vector2.One, out hoveredSnippet);
            if (hoveredSnippet > -1)
            {
                array[hoveredSnippet].OnHover();
                if (mouseLeft && mouseLeftRelease)
                {
                    array[hoveredSnippet].OnClick();
                }
            }
        }
        chatMonitor.DrawChat(drawingPlayerChat);
        if (drawingPlayerChat && array != null)
        {
            Vector2 stringSize = ChatManager.GetStringSize(FontAssets.MouseText.Value, array, Vector2.Zero);
            DrawWindowsIMEPanel(new Vector2(88f, screenHeight - 30) + new Vector2(stringSize.X + 10f, -6f));
        }
        TimeLogger.DetailedDrawTime(10);
    }
 
    protected void DrawInventory()
    {
        Recipe.GetThroughDelayedFindRecipes();
        if (ShouldPVPDraw)
        {
            DrawPVPIcons();
        }
        int num = 0;
        int num2 = 0;
        int num3 = screenWidth;
        int num4 = 0;
        int num5 = screenWidth;
        int num6 = 0;
        Vector2 vector = new Vector2(num, num2);
        new Vector2(num3, num4);
        new Vector2(num5, num6);
        DrawBestiaryIcon(num, num2);
        DrawEmoteBubblesButton(num, num2);
        DrawTrashItemSlot(num, num2);
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[4].Value, new Vector2(40f, 0f) + vector, new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        inventoryScale = 0.85f;
        if (mouseX > 20 && mouseX < (int)(20f + 560f * inventoryScale) && mouseY > 20 && mouseY < (int)(20f + 280f * inventoryScale) && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
        }
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                int num7 = (int)(20f + (float)(i * 56) * inventoryScale) + num;
                int num8 = (int)(20f + (float)(j * 56) * inventoryScale) + num2;
                int num9 = i + j * 10;
                new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
                if (mouseX >= num7 && (float)mouseX <= (float)num7 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num8 && (float)mouseY <= (float)num8 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    ItemSlot.OverrideHover(player[myPlayer].inventory, 0, num9);
                    if (player[myPlayer].inventoryChestStack[num9] && (player[myPlayer].inventory[num9].type == 0 || player[myPlayer].inventory[num9].stack == 0))
                    {
                        player[myPlayer].inventoryChestStack[num9] = false;
                    }
                    if (!player[myPlayer].inventoryChestStack[num9])
                    {
                        ItemSlot.LeftClick(player[myPlayer].inventory, 0, num9);
                        ItemSlot.RightClick(player[myPlayer].inventory, 0, num9);
                        if (mouseLeftRelease && mouseLeft)
                        {
                            Recipe.FindRecipes();
                        }
                    }
                    ItemSlot.MouseHover(player[myPlayer].inventory, 0, num9);
                }
                ItemSlot.Draw(spriteBatch, player[myPlayer].inventory, 0, num9, new Vector2(num7, num8));
            }
        }
        GetBuilderAccsCountToShow(LocalPlayer, out var _, out var _, out var totalDrawnIcons);
        bool pushSideToolsUp = totalDrawnIcons >= 10;
        if (!PlayerInput.UsingGamepad)
        {
            DrawHotbarLockIcon(num, num2, pushSideToolsUp);
        }
        ItemSlot.DrawRadialDpad(spriteBatch, new Vector2(20f) + new Vector2(56f * inventoryScale * 10f, 56f * inventoryScale * 5f) + new Vector2(26f, 70f) + vector);
        if (_achievementAdvisor.CanDrawAboveCoins)
        {
            int num10 = (int)(20f + 560f * inventoryScale) + num;
            int num11 = (int)(20f + 0f * inventoryScale) + num2;
            _achievementAdvisor.DrawOneAchievement(spriteBatch, new Vector2(num10, num11) + new Vector2(5f), large: true);
        }
        if (mapEnabled)
        {
            bool flag = false;
            int num12 = num3 - 440;
            int num13 = 40 + num4;
            if (screenWidth < 940)
            {
                flag = true;
            }
            if (flag)
            {
                num12 = num5 - 40;
                num13 = num6 - 200;
            }
            int num14 = 0;
            for (int k = 0; k < 4; k++)
            {
                int num15 = 255;
                int num16 = num12 + k * 32 - num14;
                int num17 = num13;
                if (flag)
                {
                    num16 = num12;
                    num17 = num13 + k * 32 - num14;
                }
                int num18 = k;
                num15 = 120;
                if (k > 0 && mapStyle == k - 1)
                {
                    num15 = 200;
                }
                if (mouseX >= num16 && mouseX <= num16 + 32 && mouseY >= num17 && mouseY <= num17 + 30 && !PlayerInput.IgnoreMouseInterface)
                {
                    num15 = 255;
                    num18 += 4;
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeft && mouseLeftRelease)
                    {
                        if (k == 0)
                        {
                            playerInventory = false;
                            player[myPlayer].SetTalkNPC(-1);
                            npcChatCornerItem = 0;
                            SoundEngine.PlaySound(10);
                            mapFullscreenScale = 2.5f;
                            mapFullscreen = true;
                            resetMapFull = true;
                        }
                        if (k == 1)
                        {
                            mapStyle = 0;
                            SoundEngine.PlaySound(12);
                        }
                        if (k == 2)
                        {
                            mapStyle = 1;
                            SoundEngine.PlaySound(12);
                        }
                        if (k == 3)
                        {
                            mapStyle = 2;
                            SoundEngine.PlaySound(12);
                        }
                    }
                }
                spriteBatch.Draw(TextureAssets.MapIcon[num18].Value, new Vector2(num16, num17), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.MapIcon[num18].Width(), TextureAssets.MapIcon[num18].Height()), new Microsoft.Xna.Framework.Color(num15, num15, num15, num15), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
        }
        if (armorHide)
        {
            armorAlpha -= 0.1f;
            if (armorAlpha < 0f)
            {
                armorAlpha = 0f;
            }
        }
        else
        {
            armorAlpha += 0.025f;
            if (armorAlpha > 1f)
            {
                armorAlpha = 1f;
            }
        }
        new Microsoft.Xna.Framework.Color((byte)((float)(int)mouseTextColor * armorAlpha), (byte)((float)(int)mouseTextColor * armorAlpha), (byte)((float)(int)mouseTextColor * armorAlpha), (byte)((float)(int)mouseTextColor * armorAlpha));
        armorHide = false;
        int num19 = 8 + player[myPlayer].GetAmountOfExtraAccessorySlotsToShow();
        int num20 = 174 + mH;
        int num21 = 950;
        _cannotDrawAccessoriesHorizontally = false;
        if (screenHeight < num21 && num19 >= 10)
        {
            num20 -= (int)(56f * inventoryScale * (float)(num19 - 9));
            _cannotDrawAccessoriesHorizontally = true;
        }
        int num22 = DrawPageIcons(num20 - 32);
        if (num22 > -1)
        {
            HoverItem = new Item();
            switch (num22)
            {
            case 1:
                hoverItemName = Lang.inter[80].Value;
                break;
            case 2:
                hoverItemName = Lang.inter[79].Value;
                break;
            case 3:
                hoverItemName = (CaptureModeDisabled ? Lang.inter[115].Value : Lang.inter[81].Value);
                break;
            }
        }
        if (EquipPage == 2)
        {
            Microsoft.Xna.Framework.Point value = new Microsoft.Xna.Framework.Point(mouseX, mouseY);
            Microsoft.Xna.Framework.Rectangle r = new Microsoft.Xna.Framework.Rectangle(0, 0, (int)((float)TextureAssets.InventoryBack.Width() * inventoryScale), (int)((float)TextureAssets.InventoryBack.Height() * inventoryScale));
            Item[] inv = player[myPlayer].miscEquips;
            int num23 = screenWidth - 92;
            int num24 = mH + 174;
            for (int l = 0; l < 2; l++)
            {
                switch (l)
                {
                case 0:
                    inv = player[myPlayer].miscEquips;
                    break;
                case 1:
                    inv = player[myPlayer].miscDyes;
                    break;
                }
                r.X = num23 + l * -47;
                for (int m = 0; m < 5; m++)
                {
                    int context = 0;
                    int num25 = -1;
                    bool flag2 = false;
                    switch (m)
                    {
                    case 0:
                        context = 19;
                        num25 = 0;
                        break;
                    case 1:
                        context = 20;
                        num25 = 1;
                        break;
                    case 2:
                        context = 18;
                        flag2 = player[myPlayer].unlockedSuperCart;
                        break;
                    case 3:
                        context = 17;
                        break;
                    case 4:
                        context = 16;
                        break;
                    }
                    if (l == 1)
                    {
                        context = 33;
                        num25 = -1;
                        flag2 = false;
                    }
                    r.Y = num24 + m * 47;
                    bool flag3 = false;
                    Texture2D value2 = TextureAssets.InventoryTickOn.Value;
                    Microsoft.Xna.Framework.Rectangle r2 = new Microsoft.Xna.Framework.Rectangle(r.Left + 34, r.Top - 2, value2.Width, value2.Height);
                    int num26 = 0;
                    if (num25 != -1)
                    {
                        if (player[myPlayer].hideMisc[num25])
                        {
                            value2 = TextureAssets.InventoryTickOff.Value;
                        }
                        if (r2.Contains(value) && !PlayerInput.IgnoreMouseInterface)
                        {
                            player[myPlayer].mouseInterface = true;
                            flag3 = true;
                            if (mouseLeft && mouseLeftRelease)
                            {
                                if (num25 == 0)
                                {
                                    player[myPlayer].TogglePet();
                                }
                                if (num25 == 1)
                                {
                                    player[myPlayer].ToggleLight();
                                }
                                mouseLeftRelease = false;
                                SoundEngine.PlaySound(12);
                                if (netMode == 1)
                                {
                                    NetMessage.SendData(4, -1, -1, null, myPlayer);
                                }
                            }
                            num26 = ((!player[myPlayer].hideMisc[num25]) ? 1 : 2);
                        }
                    }
                    if (flag2)
                    {
                        value2 = TextureAssets.Extra[255].Value;
                        if (!player[myPlayer].enabledSuperCart)
                        {
                            value2 = TextureAssets.Extra[256].Value;
                        }
                        r2 = new Microsoft.Xna.Framework.Rectangle(r2.X + r2.Width / 2, r2.Y + r2.Height / 2, r2.Width, r2.Height);
                        r2.Offset(-r2.Width / 2, -r2.Height / 2);
                        if (r2.Contains(value) && !PlayerInput.IgnoreMouseInterface)
                        {
                            player[myPlayer].mouseInterface = true;
                            flag3 = true;
                            if (mouseLeft && mouseLeftRelease)
                            {
                                player[myPlayer].enabledSuperCart = !player[myPlayer].enabledSuperCart;
                                mouseLeftRelease = false;
                                SoundEngine.PlaySound(12);
                                if (netMode == 1)
                                {
                                    NetMessage.SendData(4, -1, -1, null, myPlayer);
                                }
                            }
                            num26 = ((!player[myPlayer].enabledSuperCart) ? 1 : 2);
                        }
                    }
                    if (r.Contains(value) && !flag3 && !PlayerInput.IgnoreMouseInterface)
                    {
                        player[myPlayer].mouseInterface = true;
                        armorHide = true;
                        ItemSlot.Handle(inv, context, m);
                    }
                    ItemSlot.Draw(spriteBatch, inv, context, m, r.TopLeft());
                    if (num25 != -1)
                    {
                        spriteBatch.Draw(value2, r2.TopLeft(), Microsoft.Xna.Framework.Color.White * 0.7f);
                        if (num26 > 0)
                        {
                            HoverItem = new Item();
                            hoverItemName = Lang.inter[58 + num26].Value;
                        }
                    }
                    if (flag2)
                    {
                        spriteBatch.Draw(value2, r2.TopLeft(), Microsoft.Xna.Framework.Color.White);
                        if (num26 > 0)
                        {
                            HoverItem = new Item();
                            hoverItemName = Language.GetTextValue((num26 == 1) ? "GameUI.SuperCartDisabled" : "GameUI.SuperCartEnabled");
                        }
                    }
                }
            }
            num24 += 247;
            num23 += 8;
            int num27 = -1;
            int num28 = 0;
            int num29 = 3;
            int num30 = 260;
            if (screenHeight > 630 + num30 * (mapStyle == 1).ToInt())
            {
                num29++;
            }
            if (screenHeight > 680 + num30 * (mapStyle == 1).ToInt())
            {
                num29++;
            }
            if (screenHeight > 730 + num30 * (mapStyle == 1).ToInt())
            {
                num29++;
            }
            int num31 = 46;
            for (int n = 0; n < Player.maxBuffs; n++)
            {
                if (player[myPlayer].buffType[n] != 0)
                {
                    int num32 = num28 / num29;
                    int num33 = num28 % num29;
                    Microsoft.Xna.Framework.Point point = new Microsoft.Xna.Framework.Point(num23 + num32 * -num31, num24 + num33 * num31);
                    num27 = DrawBuffIcon(num27, n, point.X, point.Y);
                    UILinkPointNavigator.SetPosition(9000 + num28, new Vector2(point.X + 30, point.Y + 30));
                    num28++;
                    if (buffAlpha[n] < 0.65f)
                    {
                        buffAlpha[n] = 0.65f;
                    }
                }
            }
            UILinkPointNavigator.Shortcuts.BUFFS_DRAWN = num28;
            UILinkPointNavigator.Shortcuts.BUFFS_PER_COLUMN = num29;
            if (num27 >= 0)
            {
                int num34 = player[myPlayer].buffType[num27];
                if (num34 > 0)
                {
                    string buffName = Lang.GetBuffName(num34);
                    string buffTooltip = GetBuffTooltip(player[myPlayer], num34);
                    if (num34 == 147)
                    {
                        bannerMouseOver = true;
                    }
                    if (meleeBuff[num34])
                    {
                        MouseTextHackZoom(buffName, -10, 0, buffTooltip);
                    }
                    else
                    {
                        MouseTextHackZoom(buffName, buffTooltip);
                    }
                }
            }
        }
        else if (EquipPage == 1)
        {
            DrawNPCHousesInUI();
        }
        else
        {
            int num35 = 4;
            if (mouseX > screenWidth - 64 - 28 && mouseX < (int)((float)(screenWidth - 64 - 28) + 56f * inventoryScale) && mouseY > num20 && mouseY < (int)((float)num20 + 448f * inventoryScale) && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
            }
            float num36 = inventoryScale;
            bool flag4 = false;
            int num37 = num19 - 1;
            bool flag5 = LocalPlayer.CanDemonHeartAccessoryBeShown();
            bool flag6 = LocalPlayer.CanMasterModeAccessoryBeShown();
            if (_settingsButtonIsPushedToSide)
            {
                num37--;
            }
            int num38 = num37 - 1;
            Microsoft.Xna.Framework.Color color = inventoryBack;
            Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(80, 80, 80, 80);
            DrawLoadoutButtons(num20, flag5, flag6);
            int num39 = -1;
            for (int num40 = 0; num40 < 10; num40++)
            {
                if ((num40 == 8 && !flag5) || (num40 == 9 && !flag6))
                {
                    continue;
                }
                num39++;
                bool flag7 = LocalPlayer.IsItemSlotUnlockedAndUsable(num40);
                if (!flag7)
                {
                    flag4 = true;
                }
                int num41 = screenWidth - 64 - 28;
                int num42 = (int)((float)num20 + (float)(num39 * 56) * inventoryScale);
                new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
                int num43 = screenWidth - 58;
                int num44 = (int)((float)(num20 - 2) + (float)(num39 * 56) * inventoryScale);
                int context2 = 8;
                if (num40 > 2)
                {
                    num42 += num35;
                    num44 += num35;
                    context2 = 10;
                }
                if (num39 == num38 && !_achievementAdvisor.CanDrawAboveCoins)
                {
                    _achievementAdvisor.DrawOneAchievement(spriteBatch, new Vector2(num41 - 10 - 47 - 47 - 14 - 14, num42 + 8), large: false);
                    UILinkPointNavigator.SetPosition(1570, new Vector2(num41 - 10 - 47 - 47 - 14 - 14, num42 + 8) + new Vector2(20f) * inventoryScale);
                }
                if (num39 == num37)
                {
                    DrawDefenseCounter(num41, num42);
                }
                Texture2D value3 = TextureAssets.InventoryTickOn.Value;
                if (player[myPlayer].hideVisibleAccessory[num40])
                {
                    value3 = TextureAssets.InventoryTickOff.Value;
                }
                Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(num43, num44, value3.Width, value3.Height);
                int num45 = 0;
                if (num40 > 2 && rectangle.Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)) && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeft && mouseLeftRelease)
                    {
                        player[myPlayer].hideVisibleAccessory[num40] = !player[myPlayer].hideVisibleAccessory[num40];
                        SoundEngine.PlaySound(12);
                        if (netMode == 1)
                        {
                            NetMessage.SendData(4, -1, -1, null, myPlayer);
                        }
                    }
                    num45 = ((!player[myPlayer].hideVisibleAccessory[num40]) ? 1 : 2);
                }
                else if (mouseX >= num41 && (float)mouseX <= (float)num41 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num42 && (float)mouseY <= (float)num42 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    armorHide = true;
                    player[myPlayer].mouseInterface = true;
                    ItemSlot.OverrideHover(player[myPlayer].armor, context2, num40);
                    if (flag7 || mouseItem.IsAir)
                    {
                        ItemSlot.LeftClick(player[myPlayer].armor, context2, num40);
                    }
                    ItemSlot.MouseHover(player[myPlayer].armor, context2, num40);
                }
                if (flag4)
                {
                    inventoryBack = color2;
                }
                ItemSlot.Draw(spriteBatch, player[myPlayer].armor, context2, num40, new Vector2(num41, num42));
                if (num40 > 2)
                {
                    spriteBatch.Draw(value3, new Vector2(num43, num44), Microsoft.Xna.Framework.Color.White * 0.7f);
                    if (num45 > 0)
                    {
                        HoverItem = new Item();
                        hoverItemName = Lang.inter[58 + num45].Value;
                    }
                }
            }
            inventoryBack = color;
            if (mouseX > screenWidth - 64 - 28 - 47 && mouseX < (int)((float)(screenWidth - 64 - 20 - 47) + 56f * inventoryScale) && mouseY > num20 && mouseY < (int)((float)num20 + 168f * inventoryScale) && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
            }
            num39 = -1;
            for (int num46 = 10; num46 < 20; num46++)
            {
                if ((num46 == 18 && !flag5) || (num46 == 19 && !flag6))
                {
                    continue;
                }
                num39++;
                bool num47 = LocalPlayer.IsItemSlotUnlockedAndUsable(num46);
                flag4 = !num47;
                bool flag8 = !num47 && !mouseItem.IsAir;
                int num48 = screenWidth - 64 - 28 - 47;
                int num49 = (int)((float)num20 + (float)(num39 * 56) * inventoryScale);
                new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
                if (num46 > 12)
                {
                    num49 += num35;
                }
                int context3 = 9;
                if (num46 > 12)
                {
                    context3 = 11;
                }
                if (mouseX >= num48 && (float)mouseX <= (float)num48 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num49 && (float)mouseY <= (float)num49 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    armorHide = true;
                    ItemSlot.OverrideHover(player[myPlayer].armor, context3, num46);
                    if (!flag8)
                    {
                        ItemSlot.LeftClick(player[myPlayer].armor, context3, num46);
                        ItemSlot.RightClick(player[myPlayer].armor, context3, num46);
                    }
                    ItemSlot.MouseHover(player[myPlayer].armor, context3, num46);
                }
                if (flag4)
                {
                    inventoryBack = color2;
                }
                ItemSlot.Draw(spriteBatch, player[myPlayer].armor, context3, num46, new Vector2(num48, num49));
            }
            inventoryBack = color;
            if (mouseX > screenWidth - 64 - 28 - 47 && mouseX < (int)((float)(screenWidth - 64 - 20 - 47) + 56f * inventoryScale) && mouseY > num20 && mouseY < (int)((float)num20 + 168f * inventoryScale) && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
            }
            num39 = -1;
            for (int num50 = 0; num50 < 10; num50++)
            {
                if ((num50 == 8 && !flag5) || (num50 == 9 && !flag6))
                {
                    continue;
                }
                num39++;
                bool num51 = LocalPlayer.IsItemSlotUnlockedAndUsable(num50);
                flag4 = !num51;
                bool flag9 = !num51 && !mouseItem.IsAir;
                int num52 = screenWidth - 64 - 28 - 47 - 47;
                int num53 = (int)((float)num20 + (float)(num39 * 56) * inventoryScale);
                new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
                if (num50 > 2)
                {
                    num53 += num35;
                }
                if (mouseX >= num52 && (float)mouseX <= (float)num52 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num53 && (float)mouseY <= (float)num53 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    armorHide = true;
                    ItemSlot.OverrideHover(player[myPlayer].dye, 12, num50);
                    if (!flag9)
                    {
                        if (mouseRightRelease && mouseRight)
                        {
                            ItemSlot.RightClick(player[myPlayer].dye, 12, num50);
                        }
                        ItemSlot.LeftClick(player[myPlayer].dye, 12, num50);
                    }
                    ItemSlot.MouseHover(player[myPlayer].dye, 12, num50);
                }
                if (flag4)
                {
                    inventoryBack = color2;
                }
                ItemSlot.Draw(spriteBatch, player[myPlayer].dye, 12, num50, new Vector2(num52, num53));
            }
            inventoryBack = color;
            inventoryScale = num36;
        }
        int num54 = (screenHeight - 600) / 2;
        int num55 = (int)((float)screenHeight / 600f * 250f);
        if (screenHeight < 700)
        {
            num54 = (screenHeight - 508) / 2;
            num55 = (int)((float)screenHeight / 600f * 200f);
        }
        else if (screenHeight < 850)
        {
            num55 = (int)((float)screenHeight / 600f * 225f);
        }
        if (craftingHide)
        {
            craftingAlpha -= 0.1f;
            if (craftingAlpha < 0f)
            {
                craftingAlpha = 0f;
            }
        }
        else
        {
            craftingAlpha += 0.025f;
            if (craftingAlpha > 1f)
            {
                craftingAlpha = 1f;
            }
        }
        Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color((byte)((float)(int)mouseTextColor * craftingAlpha), (byte)((float)(int)mouseTextColor * craftingAlpha), (byte)((float)(int)mouseTextColor * craftingAlpha), (byte)((float)(int)mouseTextColor * craftingAlpha));
        craftingHide = false;
        if (InReforgeMenu)
        {
            if (mouseReforge)
            {
                if (reforgeScale < 1f)
                {
                    reforgeScale += 0.02f;
                }
            }
            else if (reforgeScale > 1f)
            {
                reforgeScale -= 0.02f;
            }
            if (player[myPlayer].chest != -1 || npcShop != 0 || player[myPlayer].talkNPC == -1 || InGuideCraftMenu)
            {
                InReforgeMenu = false;
                player[myPlayer].dropItemCheck();
                Recipe.FindRecipes();
            }
            else
            {
                int num56 = 50;
                int num57 = 270;
                string text = Lang.inter[46].Value + ": ";
                if (reforgeItem.type > 0)
                {
                    int num58 = reforgeItem.value;
                    if (player[myPlayer].discountAvailable)
                    {
                        num58 = (int)((double)num58 * 0.8);
                    }
                    num58 = (int)((double)num58 * player[myPlayer].currentShoppingSettings.PriceAdjustment);
                    num58 /= 3;
                    string text2 = "";
                    int num59 = 0;
                    int num60 = 0;
                    int num61 = 0;
                    int num62 = 0;
                    int num63 = num58;
                    if (num63 < 1)
                    {
                        num63 = 1;
                    }
                    if (num63 >= 1000000)
                    {
                        num59 = num63 / 1000000;
                        num63 -= num59 * 1000000;
                    }
                    if (num63 >= 10000)
                    {
                        num60 = num63 / 10000;
                        num63 -= num60 * 10000;
                    }
                    if (num63 >= 100)
                    {
                        num61 = num63 / 100;
                        num63 -= num61 * 100;
                    }
                    if (num63 >= 1)
                    {
                        num62 = num63;
                    }
                    if (num59 > 0)
                    {
                        text2 = text2 + "[c/" + Colors.AlphaDarken(Colors.CoinPlatinum).Hex3() + ":" + num59 + " " + Lang.inter[15].Value + "] ";
                    }
                    if (num60 > 0)
                    {
                        text2 = text2 + "[c/" + Colors.AlphaDarken(Colors.CoinGold).Hex3() + ":" + num60 + " " + Lang.inter[16].Value + "] ";
                    }
                    if (num61 > 0)
                    {
                        text2 = text2 + "[c/" + Colors.AlphaDarken(Colors.CoinSilver).Hex3() + ":" + num61 + " " + Lang.inter[17].Value + "] ";
                    }
                    if (num62 > 0)
                    {
                        text2 = text2 + "[c/" + Colors.AlphaDarken(Colors.CoinCopper).Hex3() + ":" + num62 + " " + Lang.inter[18].Value + "] ";
                    }
                    ItemSlot.DrawSavings(spriteBatch, num56 + 130, invBottom, horizontal: true);
                    ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, text2, new Vector2((float)(num56 + 50) + FontAssets.MouseText.Value.MeasureString(text).X, num57), Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, Vector2.One);
                    int num64 = num56 + 70;
                    int num65 = num57 + 40;
                    bool num66 = mouseX > num64 - 15 && mouseX < num64 + 15 && mouseY > num65 - 15 && mouseY < num65 + 15 && !PlayerInput.IgnoreMouseInterface;
                    Texture2D value4 = TextureAssets.Reforge[0].Value;
                    if (num66)
                    {
                        value4 = TextureAssets.Reforge[1].Value;
                    }
                    spriteBatch.Draw(value4, new Vector2(num64, num65), null, Microsoft.Xna.Framework.Color.White, 0f, value4.Size() / 2f, reforgeScale, SpriteEffects.None, 0f);
                    UILinkPointNavigator.SetPosition(304, new Vector2(num64, num65) + value4.Size() / 4f);
                    if (num66)
                    {
                        hoverItemName = Lang.inter[19].Value;
                        if (!mouseReforge)
                        {
                            SoundEngine.PlaySound(12);
                        }
                        mouseReforge = true;
                        player[myPlayer].mouseInterface = true;
                        if (mouseLeftRelease && mouseLeft && player[myPlayer].BuyItem(num58))
                        {
                            reforgeItem.ResetPrefix();
                            reforgeItem.Prefix(-2);
                            reforgeItem.position.X = player[myPlayer].position.X + (float)(player[myPlayer].width / 2) - (float)(reforgeItem.width / 2);
                            reforgeItem.position.Y = player[myPlayer].position.Y + (float)(player[myPlayer].height / 2) - (float)(reforgeItem.height / 2);
                            PopupText.NewText(PopupTextContext.ItemReforge, reforgeItem, reforgeItem.stack, noStack: true);
                            SoundEngine.PlaySound(SoundID.Item37);
                        }
                    }
                    else
                    {
                        mouseReforge = false;
                    }
                }
                else
                {
                    text = Lang.inter[20].Value;
                }
                ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(num56 + 50, num57), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, Vector2.Zero, Vector2.One);
                if (mouseX >= num56 && (float)mouseX <= (float)num56 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num57 && (float)mouseY <= (float)num57 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    craftingHide = true;
                    ItemSlot.LeftClick(ref reforgeItem, 5);
                    if (mouseLeftRelease && mouseLeft)
                    {
                        Recipe.FindRecipes();
                    }
                    ItemSlot.RightClick(ref reforgeItem, 5);
                    ItemSlot.MouseHover(ref reforgeItem, 5);
                }
                ItemSlot.Draw(spriteBatch, ref reforgeItem, 5, new Vector2(num56, num57));
            }
        }
        else if (InGuideCraftMenu)
        {
            if (player[myPlayer].chest != -1 || npcShop != 0 || player[myPlayer].talkNPC == -1 || InReforgeMenu)
            {
                InGuideCraftMenu = false;
                player[myPlayer].dropItemCheck();
                Recipe.FindRecipes();
            }
            else
            {
                DrawGuideCraftText(num54, color3, out var inventoryX, out var inventoryY);
                new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
                if (mouseX >= inventoryX && (float)mouseX <= (float)inventoryX + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= inventoryY && (float)mouseY <= (float)inventoryY + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    craftingHide = true;
                    ItemSlot.OverrideHover(ref guideItem, 7);
                    ItemSlot.LeftClick(ref guideItem, 7);
                    if (mouseLeftRelease && mouseLeft)
                    {
                        Recipe.FindRecipes();
                    }
                    ItemSlot.RightClick(ref guideItem, 7);
                    ItemSlot.MouseHover(ref guideItem, 7);
                }
                ItemSlot.Draw(spriteBatch, ref guideItem, 7, new Vector2(inventoryX, inventoryY));
            }
        }
        CreativeMenu.Draw(spriteBatch);
        bool flag10 = CreativeMenu.Enabled && !CreativeMenu.Blocked;
        if (!InReforgeMenu && !LocalPlayer.tileEntityAnchor.InUse && !flag10)
        {
            UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeBig = -1;
            UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall = -1;
            if (numAvailableRecipes > 0)
            {
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[25].Value, new Vector2(76f, 414 + num54), color3, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            for (int num67 = 0; num67 < Recipe.maxRecipes; num67++)
            {
                inventoryScale = 100f / (Math.Abs(availableRecipeY[num67]) + 100f);
                if ((double)inventoryScale < 0.75)
                {
                    inventoryScale = 0.75f;
                }
                if (recFastScroll)
                {
                    inventoryScale = 0.75f;
                }
                if (availableRecipeY[num67] < (float)((num67 - focusRecipe) * 65))
                {
                    if (availableRecipeY[num67] == 0f && !recFastScroll)
                    {
                        SoundEngine.PlaySound(12);
                    }
                    availableRecipeY[num67] += 6.5f;
                    if (recFastScroll)
                    {
                        availableRecipeY[num67] += 130000f;
                    }
                    if (availableRecipeY[num67] > (float)((num67 - focusRecipe) * 65))
                    {
                        availableRecipeY[num67] = (num67 - focusRecipe) * 65;
                    }
                }
                else if (availableRecipeY[num67] > (float)((num67 - focusRecipe) * 65))
                {
                    if (availableRecipeY[num67] == 0f && !recFastScroll)
                    {
                        SoundEngine.PlaySound(12);
                    }
                    availableRecipeY[num67] -= 6.5f;
                    if (recFastScroll)
                    {
                        availableRecipeY[num67] -= 130000f;
                    }
                    if (availableRecipeY[num67] < (float)((num67 - focusRecipe) * 65))
                    {
                        availableRecipeY[num67] = (num67 - focusRecipe) * 65;
                    }
                }
                else
                {
                    recFastScroll = false;
                }
                if (num67 >= numAvailableRecipes || Math.Abs(availableRecipeY[num67]) > (float)num55)
                {
                    continue;
                }
                int num68 = (int)(46f - 26f * inventoryScale);
                int num69 = (int)(410f + availableRecipeY[num67] * inventoryScale - 30f * inventoryScale + (float)num54);
                double num70 = inventoryBack.A + 50;
                double num71 = 255.0;
                if (Math.Abs(availableRecipeY[num67]) > (float)num55 - 100f)
                {
                    num70 = (double)(150f * (100f - (Math.Abs(availableRecipeY[num67]) - ((float)num55 - 100f)))) * 0.01;
                    num71 = (double)(255f * (100f - (Math.Abs(availableRecipeY[num67]) - ((float)num55 - 100f)))) * 0.01;
                }
                new Microsoft.Xna.Framework.Color((byte)num70, (byte)num70, (byte)num70, (byte)num70);
                Microsoft.Xna.Framework.Color lightColor = new Microsoft.Xna.Framework.Color((byte)num71, (byte)num71, (byte)num71, (byte)num71);
                if (!LocalPlayer.creativeInterface && mouseX >= num68 && (float)mouseX <= (float)num68 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num69 && (float)mouseY <= (float)num69 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    HoverOverCraftingItemButton(num67);
                }
                if (numAvailableRecipes <= 0)
                {
                    continue;
                }
                num70 -= 50.0;
                if (num70 < 0.0)
                {
                    num70 = 0.0;
                }
                if (num67 == focusRecipe)
                {
                    UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall = 0;
                    if (PlayerInput.SettingsForUI.HighlightThingsForMouse)
                    {
                        ItemSlot.DrawGoldBGForCraftingMaterial = true;
                    }
                }
                else
                {
                    UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall = -1;
                }
                Microsoft.Xna.Framework.Color color4 = inventoryBack;
                inventoryBack = new Microsoft.Xna.Framework.Color((byte)num70, (byte)num70, (byte)num70, (byte)num70);
                ItemSlot.Draw(spriteBatch, ref recipe[availableRecipe[num67]].createItem, 22, new Vector2(num68, num69), lightColor);
                inventoryBack = color4;
            }
            if (numAvailableRecipes > 0)
            {
                UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeBig = -1;
                UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall = -1;
                for (int num72 = 0; num72 < Recipe.maxRequirements; num72++)
                {
                    if (recipe[availableRecipe[focusRecipe]].requiredItem[num72].type == 0)
                    {
                        UILinkPointNavigator.Shortcuts.CRAFT_CurrentIngredientsCount = num72 + 1;
                        break;
                    }
                    int num73 = 80 + num72 * 40;
                    int num74 = 380 + num54;
                    double num75 = inventoryBack.A + 50;
                    double num76 = 255.0;
                    Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
                    Microsoft.Xna.Framework.Color white2 = Microsoft.Xna.Framework.Color.White;
                    num75 = (float)(inventoryBack.A + 50) - Math.Abs(availableRecipeY[focusRecipe]) * 2f;
                    num76 = 255f - Math.Abs(availableRecipeY[focusRecipe]) * 2f;
                    if (num75 < 0.0)
                    {
                        num75 = 0.0;
                    }
                    if (num76 < 0.0)
                    {
                        num76 = 0.0;
                    }
                    white.R = (byte)num75;
                    white.G = (byte)num75;
                    white.B = (byte)num75;
                    white.A = (byte)num75;
                    white2.R = (byte)num76;
                    white2.G = (byte)num76;
                    white2.B = (byte)num76;
                    white2.A = (byte)num76;
                    inventoryScale = 0.6f;
                    if (num75 == 0.0)
                    {
                        break;
                    }
                    if (mouseX >= num73 && (float)mouseX <= (float)num73 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num74 && (float)mouseY <= (float)num74 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                    {
                        craftingHide = true;
                        player[myPlayer].mouseInterface = true;
                        SetRecipeMaterialDisplayName(num72);
                    }
                    num75 -= 50.0;
                    if (num75 < 0.0)
                    {
                        num75 = 0.0;
                    }
                    UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall = 1 + num72;
                    Microsoft.Xna.Framework.Color color5 = inventoryBack;
                    inventoryBack = new Microsoft.Xna.Framework.Color((byte)num75, (byte)num75, (byte)num75, (byte)num75);
                    ItemSlot.Draw(spriteBatch, ref recipe[availableRecipe[focusRecipe]].requiredItem[num72], 22, new Vector2(num73, num74));
                    inventoryBack = color5;
                }
            }
            if (numAvailableRecipes == 0)
            {
                recBigList = false;
            }
            else
            {
                int num77 = 94;
                int num78 = 450 + num54;
                if (InGuideCraftMenu)
                {
                    num78 -= 150;
                }
                bool flag11 = mouseX > num77 - 15 && mouseX < num77 + 15 && mouseY > num78 - 15 && mouseY < num78 + 15 && !PlayerInput.IgnoreMouseInterface;
                int num79 = recBigList.ToInt() * 2 + flag11.ToInt();
                spriteBatch.Draw(TextureAssets.CraftToggle[num79].Value, new Vector2(num77, num78), null, Microsoft.Xna.Framework.Color.White, 0f, TextureAssets.CraftToggle[num79].Value.Size() / 2f, 1f, SpriteEffects.None, 0f);
                if (flag11)
                {
                    MouseText(Language.GetTextValue("GameUI.CraftingWindow"), 0, 0);
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeft && mouseLeftRelease)
                    {
                        if (!recBigList)
                        {
                            recBigList = true;
                            SoundEngine.PlaySound(12);
                        }
                        else
                        {
                            recBigList = false;
                            SoundEngine.PlaySound(12);
                        }
                    }
                }
            }
        }
        if (recBigList && !flag10)
        {
            UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeBig = -1;
            UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeSmall = -1;
            int num80 = 42;
            if ((double)inventoryScale < 0.75)
            {
                inventoryScale = 0.75f;
            }
            int num81 = 340;
            int num82 = 310;
            int num83 = (screenWidth - num82 - 280) / num80;
            int num84 = (screenHeight - num81 - 20) / num80;
            UILinkPointNavigator.Shortcuts.CRAFT_IconsPerRow = num83;
            UILinkPointNavigator.Shortcuts.CRAFT_IconsPerColumn = num84;
            int num85 = 0;
            int num86 = 0;
            int num87 = num82;
            int num88 = num81;
            int num89 = num82 - 20;
            int num90 = num81 + 2;
            if (recStart > numAvailableRecipes - num83 * num84)
            {
                recStart = numAvailableRecipes - num83 * num84;
                if (recStart < 0)
                {
                    recStart = 0;
                }
            }
            if (recStart > 0)
            {
                if (mouseX >= num89 && mouseX <= num89 + TextureAssets.CraftUpButton.Width() && mouseY >= num90 && mouseY <= num90 + TextureAssets.CraftUpButton.Height() && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeftRelease && mouseLeft)
                    {
                        recStart -= num83;
                        if (recStart < 0)
                        {
                            recStart = 0;
                        }
                        SoundEngine.PlaySound(12);
                        mouseLeftRelease = false;
                    }
                }
                spriteBatch.Draw(TextureAssets.CraftUpButton.Value, new Vector2(num89, num90), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.CraftUpButton.Width(), TextureAssets.CraftUpButton.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (recStart < numAvailableRecipes - num83 * num84)
            {
                num90 += 20;
                if (mouseX >= num89 && mouseX <= num89 + TextureAssets.CraftUpButton.Width() && mouseY >= num90 && mouseY <= num90 + TextureAssets.CraftUpButton.Height() && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeftRelease && mouseLeft)
                    {
                        recStart += num83;
                        SoundEngine.PlaySound(12);
                        if (recStart > numAvailableRecipes - num83)
                        {
                            recStart = numAvailableRecipes - num83;
                        }
                        mouseLeftRelease = false;
                    }
                }
                spriteBatch.Draw(TextureAssets.CraftDownButton.Value, new Vector2(num89, num90), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.CraftUpButton.Width(), TextureAssets.CraftUpButton.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            for (int num91 = recStart; num91 < Recipe.maxRecipes && num91 < numAvailableRecipes; num91++)
            {
                int num92 = num87;
                int num93 = num88;
                double num94 = inventoryBack.A + 50;
                double num95 = 255.0;
                new Microsoft.Xna.Framework.Color((byte)num94, (byte)num94, (byte)num94, (byte)num94);
                new Microsoft.Xna.Framework.Color((byte)num95, (byte)num95, (byte)num95, (byte)num95);
                if (mouseX >= num92 && (float)mouseX <= (float)num92 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num93 && (float)mouseY <= (float)num93 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeftRelease && mouseLeft)
                    {
                        focusRecipe = num91;
                        recFastScroll = true;
                        recBigList = false;
                        SoundEngine.PlaySound(12);
                        mouseLeftRelease = false;
                        if (PlayerInput.UsingGamepadUI)
                        {
                            UILinkPointNavigator.ChangePage(9);
                            LockCraftingForThisCraftClickDuration();
                        }
                    }
                    craftingHide = true;
                    HoverItem = recipe[availableRecipe[num91]].createItem.Clone();
                    ItemSlot.MouseHover(22);
                    hoverItemName = recipe[availableRecipe[num91]].createItem.Name;
                    if (recipe[availableRecipe[num91]].createItem.stack > 1)
                    {
                        hoverItemName = hoverItemName + " (" + recipe[availableRecipe[num91]].createItem.stack + ")";
                    }
                }
                if (numAvailableRecipes > 0)
                {
                    num94 -= 50.0;
                    if (num94 < 0.0)
                    {
                        num94 = 0.0;
                    }
                    UILinkPointNavigator.Shortcuts.CRAFT_CurrentRecipeBig = num91 - recStart;
                    Microsoft.Xna.Framework.Color color6 = inventoryBack;
                    inventoryBack = new Microsoft.Xna.Framework.Color((byte)num94, (byte)num94, (byte)num94, (byte)num94);
                    ItemSlot.Draw(spriteBatch, ref recipe[availableRecipe[num91]].createItem, 22, new Vector2(num92, num93));
                    inventoryBack = color6;
                }
                num87 += num80;
                num85++;
                if (num85 >= num83)
                {
                    num87 = num82;
                    num88 += num80;
                    num85 = 0;
                    num86++;
                    if (num86 >= num84)
                    {
                        break;
                    }
                }
            }
        }
        Vector2 vector2 = FontAssets.MouseText.Value.MeasureString("Coins");
        Vector2 vector3 = FontAssets.MouseText.Value.MeasureString(Lang.inter[26].Value);
        float num96 = vector2.X / vector3.X;
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[26].Value, new Vector2(496f, 84f + (vector2.Y - vector2.Y * num96) / 2f), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 0.75f * num96, SpriteEffects.None, 0f);
        inventoryScale = 0.6f;
        for (int num97 = 0; num97 < 4; num97++)
        {
            int num98 = 497;
            int num99 = (int)(85f + (float)(num97 * 56) * inventoryScale + 20f);
            int slot = num97 + 50;
            new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
            if (mouseX >= num98 && (float)mouseX <= (float)num98 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num99 && (float)mouseY <= (float)num99 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
                ItemSlot.OverrideHover(player[myPlayer].inventory, 1, slot);
                ItemSlot.LeftClick(player[myPlayer].inventory, 1, slot);
                ItemSlot.RightClick(player[myPlayer].inventory, 1, slot);
                if (mouseLeftRelease && mouseLeft)
                {
                    Recipe.FindRecipes();
                }
                ItemSlot.MouseHover(player[myPlayer].inventory, 1, slot);
            }
            ItemSlot.Draw(spriteBatch, player[myPlayer].inventory, 1, slot, new Vector2(num98, num99));
        }
        Vector2 vector4 = FontAssets.MouseText.Value.MeasureString("Ammo");
        Vector2 vector5 = FontAssets.MouseText.Value.MeasureString(Lang.inter[27].Value);
        float num100 = vector4.X / vector5.X;
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[27].Value, new Vector2(532f, 84f + (vector4.Y - vector4.Y * num100) / 2f), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 0.75f * num100, SpriteEffects.None, 0f);
        inventoryScale = 0.6f;
        for (int num101 = 0; num101 < 4; num101++)
        {
            int num102 = 534;
            int num103 = (int)(85f + (float)(num101 * 56) * inventoryScale + 20f);
            int slot2 = 54 + num101;
            new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
            if (mouseX >= num102 && (float)mouseX <= (float)num102 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num103 && (float)mouseY <= (float)num103 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
                ItemSlot.OverrideHover(player[myPlayer].inventory, 2, slot2);
                ItemSlot.LeftClick(player[myPlayer].inventory, 2, slot2);
                ItemSlot.RightClick(player[myPlayer].inventory, 2, slot2);
                if (mouseLeftRelease && mouseLeft)
                {
                    Recipe.FindRecipes();
                }
                ItemSlot.MouseHover(player[myPlayer].inventory, 2, slot2);
            }
            ItemSlot.Draw(spriteBatch, player[myPlayer].inventory, 2, slot2, new Vector2(num102, num103));
        }
        if (npcShop > 0 && (!playerInventory || player[myPlayer].talkNPC == -1))
        {
            SetNPCShopIndex(0);
        }
        if (npcShop > 0 && !recBigList)
        {
            Utils.DrawBorderStringFourWay(spriteBatch, FontAssets.MouseText.Value, Lang.inter[28].Value, 504f, invBottom, Microsoft.Xna.Framework.Color.White * ((float)(int)mouseTextColor / 255f), Microsoft.Xna.Framework.Color.Black, Vector2.Zero);
            ItemSlot.DrawSavings(spriteBatch, 504f, invBottom);
            inventoryScale = 0.755f;
            if (mouseX > 73 && mouseX < (int)(73f + 560f * inventoryScale) && mouseY > invBottom && mouseY < (int)((float)invBottom + 224f * inventoryScale) && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
            }
            for (int num104 = 0; num104 < 10; num104++)
            {
                for (int num105 = 0; num105 < 4; num105++)
                {
                    int num106 = (int)(73f + (float)(num104 * 56) * inventoryScale);
                    int num107 = (int)((float)invBottom + (float)(num105 * 56) * inventoryScale);
                    int slot3 = num104 + num105 * 10;
                    new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
                    if (mouseX >= num106 && (float)mouseX <= (float)num106 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num107 && (float)mouseY <= (float)num107 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
                    {
                        ItemSlot.OverrideHover(shop[npcShop].item, 15, slot3);
                        player[myPlayer].mouseInterface = true;
                        ItemSlot.LeftClick(shop[npcShop].item, 15, slot3);
                        ItemSlot.RightClick(shop[npcShop].item, 15, slot3);
                        ItemSlot.MouseHover(shop[npcShop].item, 15, slot3);
                    }
                    ItemSlot.Draw(spriteBatch, shop[npcShop].item, 15, slot3, new Vector2(num106, num107));
                }
            }
        }
        if (player[myPlayer].chest > -1 && !tileContainer[tile[player[myPlayer].chestX, player[myPlayer].chestY].type])
        {
            player[myPlayer].chest = -1;
            Recipe.FindRecipes();
        }
        int offsetDown = 0;
        UIVirtualKeyboard.ShouldHideText = !PlayerInput.SettingsForUI.ShowGamepadHints;
        if (!PlayerInput.UsingGamepad)
        {
            offsetDown = 9999;
        }
        UIVirtualKeyboard.OffsetDown = offsetDown;
        ChestUI.Draw(spriteBatch);
        LocalPlayer.tileEntityAnchor.GetTileEntity()?.OnInventoryDraw(LocalPlayer, spriteBatch);
        if (player[myPlayer].chest == -1 && npcShop == 0)
        {
            int num108 = 0;
            int num109 = 498;
            int num110 = 244;
            int num111 = TextureAssets.ChestStack[num108].Width();
            int num112 = TextureAssets.ChestStack[num108].Height();
            UILinkPointNavigator.SetPosition(301, new Vector2((float)num109 + (float)num111 * 0.75f, (float)num110 + (float)num112 * 0.75f));
            if (mouseX >= num109 && mouseX <= num109 + num111 && mouseY >= num110 && mouseY <= num110 + num112 && !PlayerInput.IgnoreMouseInterface)
            {
                num108 = 1;
                if (!allChestStackHover)
                {
                    SoundEngine.PlaySound(12);
                    allChestStackHover = true;
                }
                if (mouseLeft && mouseLeftRelease)
                {
                    mouseLeftRelease = false;
                    player[myPlayer].QuickStackAllChests();
                    Recipe.FindRecipes();
                }
                player[myPlayer].mouseInterface = true;
            }
            else if (allChestStackHover)
            {
                SoundEngine.PlaySound(12);
                allChestStackHover = false;
            }
            spriteBatch.Draw(TextureAssets.ChestStack[num108].Value, new Vector2(num109, num110), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.ChestStack[num108].Width(), TextureAssets.ChestStack[num108].Height()), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            if (!mouseText && num108 == 1)
            {
                MouseText(Language.GetTextValue("GameUI.QuickStackToNearby"), 0, 0);
            }
        }
        if (player[myPlayer].chest != -1 || npcShop != 0)
        {
            return;
        }
        int num113 = 0;
        int num114 = 534;
        int num115 = 244;
        int num116 = 30;
        int num117 = 30;
        UILinkPointNavigator.SetPosition(302, new Vector2((float)num114 + (float)num116 * 0.75f, (float)num115 + (float)num117 * 0.75f));
        bool flag12 = false;
        if (mouseX >= num114 && mouseX <= num114 + num116 && mouseY >= num115 && mouseY <= num115 + num117 && !PlayerInput.IgnoreMouseInterface)
        {
            num113 = 1;
            flag12 = true;
            player[myPlayer].mouseInterface = true;
            if (mouseLeft && mouseLeftRelease)
            {
                mouseLeftRelease = false;
                ItemSorting.SortInventory();
                Recipe.FindRecipes();
            }
        }
        if (flag12 != inventorySortMouseOver)
        {
            SoundEngine.PlaySound(12);
            inventorySortMouseOver = flag12;
        }
        Texture2D value5 = TextureAssets.InventorySort[inventorySortMouseOver ? 1 : 0].Value;
        spriteBatch.Draw(value5, new Vector2(num114, num115), null, Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        if (!mouseText && num113 == 1)
        {
            MouseText(Language.GetTextValue("GameUI.SortInventory"), 0, 0);
        }
    }
 
    private static void DrawLoadoutButtons(int inventoryTop, bool demonHeartSlotAvailable, bool masterModeSlotAvailable)
    {
        int num = 10;
        Player player = Main.player[myPlayer];
        if (!demonHeartSlotAvailable)
        {
            num--;
        }
        if (!masterModeSlotAvailable)
        {
            num--;
        }
        int x = screenWidth - 58 + 14;
        int num2 = (int)((float)(inventoryTop - 2) + 0f * inventoryScale);
        int num3 = (int)((float)(inventoryTop - 2) + (float)(num * 56) * inventoryScale);
        Texture2D value = TextureAssets.Extra[259].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(x, num2 + 2, 4, num3 - num2);
        ItemSlot.GetLoadoutColor(player.CurrentLoadoutIndex);
        int num4 = player.Loadouts.Length;
        int num5 = 32;
        int num6 = 4;
        int num7 = -1;
        _ = FontAssets.ItemStack.Value;
        for (int i = 0; i < num4; i++)
        {
            Microsoft.Xna.Framework.Rectangle rectangle2 = new Microsoft.Xna.Framework.Rectangle(rectangle.X + rectangle.Width, rectangle.Y + (num5 + num6) * i, 32, num5);
            Microsoft.Xna.Framework.Color loadoutColor = ItemSlot.GetLoadoutColor(i);
            _ = player.Loadouts[i];
            int frameX = ((i == player.CurrentLoadoutIndex) ? 1 : 0);
            bool flag = false;
            if (rectangle2.Contains(MouseScreen.ToPoint()))
            {
                flag = true;
                loadoutColor = Microsoft.Xna.Framework.Color.Lerp(loadoutColor, Microsoft.Xna.Framework.Color.White, 0.8f);
                player.mouseInterface = true;
                if (!mouseText)
                {
                    instance.MouseText(Language.GetTextValue("UI.Loadout" + (i + 1)), 0, 0);
                    mouseText = true;
                }
                if (mouseLeft && mouseLeftRelease)
                {
                    player.TrySwitchingLoadout(i);
                }
            }
            Microsoft.Xna.Framework.Rectangle rectangle3 = value.Frame(3, 3, frameX, i);
            spriteBatch.Draw(value, rectangle2.Center.ToVector2(), rectangle3, Microsoft.Xna.Framework.Color.White, 0f, rectangle3.Size() / 2f, 1f, SpriteEffects.None, 0f);
            if (flag)
            {
                rectangle3 = value.Frame(3, 3, 2, i);
                spriteBatch.Draw(value, rectangle2.Center.ToVector2(), rectangle3, OurFavoriteColor, 0f, rectangle3.Size() / 2f, 1f, SpriteEffects.None, 0f);
            }
            UILinkPointNavigator.SetPosition(312 + i, rectangle2.Center.ToVector2());
        }
        if (_lastHoveredLoadoutIndex != num7)
        {
            _lastHoveredLoadoutIndex = num7;
            SoundEngine.PlaySound(12);
        }
    }
 
    private void DrawNPCHousesInUI()
    {
        UILinkPointNavigator.Shortcuts.NPCS_LastHovered = -2;
        if (mouseX > screenWidth - 64 - 28 && mouseX < (int)((float)(screenWidth - 64 - 28) + 56f * inventoryScale) && mouseY > 174 + mH && mouseY < (int)((float)(174 + mH) + 448f * inventoryScale) && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
        }
        int num = 0;
        string text = "";
        int num2 = 0;
        int num3 = 0;
        _npcTypesThatAlreadyDrewAHead.Clear();
        for (int i = 0; i < _npcIndexWhoHoldsHeadIndex.Length; i++)
        {
            _npcIndexWhoHoldsHeadIndex[i] = -1;
        }
        for (int j = 0; j < 200; j++)
        {
            if (npc[j].active && !_npcTypesThatAlreadyDrewAHead.Contains(npc[j].type))
            {
                int headIndexSafe = TownNPCProfiles.GetHeadIndexSafe(npc[j]);
                if (headIndexSafe > 0 && headIndexSafe <= NPCHeadID.Count && !NPCHeadID.Sets.CannotBeDrawnInHousingUI[headIndexSafe] && _npcIndexWhoHoldsHeadIndex[headIndexSafe] == -1)
                {
                    _npcIndexWhoHoldsHeadIndex[headIndexSafe] = j;
                    _npcTypesThatAlreadyDrewAHead.Add(npc[j].type);
                }
            }
        }
        hidePVPIcons = false;
        int num4 = 0;
        int num5 = 0;
        UILinkPointNavigator.Shortcuts.NPCS_IconsPerColumn = 1;
        for (int k = 0; k < TextureAssets.NpcHead.Length; k++)
        {
            if (k != 0 && _npcIndexWhoHoldsHeadIndex[k] == -1)
            {
                continue;
            }
            int num6 = _npcIndexWhoHoldsHeadIndex[k];
            int num7 = screenWidth - 64 - 28 + num3;
            int num8 = (int)((float)(174 + mH) + (float)(num * 56) * inventoryScale) + num2;
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(100, 100, 100, 100);
            if (num8 > screenHeight - 80)
            {
                num3 -= 48;
                num2 -= num8 - (174 + mH);
                num7 = screenWidth - 64 - 28 + num3;
                num8 = (int)((float)(174 + mH) + (float)(num * 56) * inventoryScale) + num2;
                UILinkPointNavigator.Shortcuts.NPCS_IconsPerColumn = num5;
                if (num3 <= -144)
                {
                    hidePVPIcons = true;
                }
                num5 = 0;
            }
            if (mouseX >= num7 && (float)mouseX <= (float)num7 + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num8 && (float)mouseY <= (float)num8 + (float)TextureAssets.InventoryBack.Height() * inventoryScale)
            {
                UILinkPointNavigator.Shortcuts.NPCS_LastHovered = num6;
                mouseText = true;
                text = ((k != 0) ? npc[num6].FullName : Lang.inter[8].Value);
                if (!PlayerInput.IgnoreMouseInterface)
                {
                    player[myPlayer].mouseInterface = true;
                    if (mouseLeftRelease && mouseLeft && !PlayerInput.UsingGamepadUI && mouseItem.type == 0)
                    {
                        SoundEngine.PlaySound(12);
                        if (k == 0)
                        {
                            SetMouseNPC_ToHousingQuery();
                        }
                        else
                        {
                            SetMouseNPC(num6, npc[num6].type);
                        }
                        mouseLeftRelease = false;
                    }
                }
            }
            UILinkPointNavigator.SetPosition(600 + num, new Vector2(num7, num8) + TextureAssets.InventoryBack.Value.Size() * 0.75f);
            Texture2D value = TextureAssets.InventoryBack11.Value;
            Microsoft.Xna.Framework.Color white = inventoryBack;
            if (UILinkPointNavigator.CurrentPoint - 600 == num)
            {
                value = TextureAssets.InventoryBack14.Value;
                white = Microsoft.Xna.Framework.Color.White;
            }
            spriteBatch.Draw(value, new Vector2(num7, num8), null, white, 0f, default(Vector2), inventoryScale, SpriteEffects.None, 0f);
            color = Microsoft.Xna.Framework.Color.White;
            int num9 = k;
            float scale = 1f;
            float num10 = 0f;
            num10 = ((TextureAssets.NpcHead[num9].Width() <= TextureAssets.NpcHead[num9].Height()) ? ((float)TextureAssets.NpcHead[num9].Height()) : ((float)TextureAssets.NpcHead[num9].Width()));
            if (num10 > 36f)
            {
                scale = 36f / num10;
            }
            spriteBatch.Draw(TextureAssets.NpcHead[num9].Value, new Vector2((float)num7 + 26f * inventoryScale, (float)num8 + 26f * inventoryScale), null, color, 0f, new Vector2(TextureAssets.NpcHead[num9].Width() / 2, TextureAssets.NpcHead[num9].Height() / 2), scale, SpriteEffects.None, 0f);
            num++;
            num4++;
            num5++;
        }
        UILinkPointNavigator.Shortcuts.NPCS_IconsTotal = num4;
        if (text != "" && mouseItem.type == 0)
        {
            MouseText(text, 0, 0);
        }
    }
 
    private static void DrawDefenseCounter(int inventoryX, int inventoryY)
    {
        Vector2 vector = new Vector2(inventoryX - 10 - 47 - 47 - 14, (float)inventoryY + (float)TextureAssets.InventoryBack.Height() * 0.5f);
        spriteBatch.Draw(TextureAssets.Extra[58].Value, vector, null, Microsoft.Xna.Framework.Color.White, 0f, TextureAssets.Extra[58].Value.Size() / 2f, inventoryScale, SpriteEffects.None, 0f);
        Vector2 vector2 = FontAssets.MouseText.Value.MeasureString(player[myPlayer].statDefense.ToString());
        ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, player[myPlayer].statDefense.ToString(), vector - vector2 * 0.5f * inventoryScale, Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, new Vector2(inventoryScale));
        if (Utils.CenteredRectangle(vector, TextureAssets.Extra[58].Value.Size()).Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)) && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
            string value = player[myPlayer].statDefense + " " + Lang.inter[10].Value;
            if (!string.IsNullOrEmpty(value))
            {
                hoverItemName = value;
            }
        }
        UILinkPointNavigator.SetPosition(1557, vector + TextureAssets.Extra[58].Value.Size() * inventoryScale / 4f);
    }
 
    private static void DrawGuideCraftText(int adjY, Microsoft.Xna.Framework.Color craftingTipColor, out int inventoryX, out int inventoryY)
    {
        inventoryX = 73;
        inventoryY = 331;
        inventoryY += adjY;
        string text = null;
        _requiredObjecsForCraftingText.Clear();
        if (guideItem.IsAir)
        {
            text = Lang.inter[24].Value;
        }
        else
        {
            text = Lang.inter[21].Value + " " + guideItem.Name;
            Recipe recipe = Main.recipe[availableRecipe[focusRecipe]];
            for (int i = 0; i < Recipe.maxRequirements; i++)
            {
                int num = recipe.requiredTile[i];
                if (num == -1)
                {
                    break;
                }
                int requiredTileStyle = Recipe.GetRequiredTileStyle(num);
                string mapObjectName = Lang.GetMapObjectName(MapHelper.TileToLookup(num, requiredTileStyle));
                _requiredObjecsForCraftingText.Add(mapObjectName);
            }
            if (recipe.needWater)
            {
                _requiredObjecsForCraftingText.Add(Lang.inter[53].Value);
            }
            if (recipe.needHoney)
            {
                _requiredObjecsForCraftingText.Add(Lang.inter[58].Value);
            }
            if (recipe.needLava)
            {
                _requiredObjecsForCraftingText.Add(Lang.inter[56].Value);
            }
            if (recipe.needSnowBiome)
            {
                _requiredObjecsForCraftingText.Add(Lang.inter[123].Value);
            }
            if (recipe.needGraveyardBiome)
            {
                _requiredObjecsForCraftingText.Add(Lang.inter[124].Value);
            }
            if (_requiredObjecsForCraftingText.Count == 0)
            {
                string value = Lang.inter[23].Value;
                _requiredObjecsForCraftingText.Add(value);
            }
        }
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
        Vector2 vector = new Vector2(inventoryX + 50, inventoryY + 12);
        DynamicSpriteFont value2 = FontAssets.MouseText.Value;
        if (_requiredObjecsForCraftingText.Count > 0)
        {
            vector.Y -= 14f;
            Vector2 vector2 = vector + new Vector2(0f, 26f);
            Microsoft.Xna.Framework.Color color2 = color;
            string value3 = Lang.inter[22].Value;
            string text2 = string.Join(", ", _requiredObjecsForCraftingText);
            string text3 = value3 + " " + text2;
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, value2, text3, vector2, color2, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
        }
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, value2, text, vector, color, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
    }
 
    private static void DrawGuideCraftText_Old(int adjY, Microsoft.Xna.Framework.Color craftingTipColor, out int inventoryX, out int inventoryY)
    {
        inventoryX = 73;
        inventoryY = 331;
        inventoryY += adjY;
        int num = 0;
        int num2 = 0;
        inventoryX += num;
        inventoryY += num2;
        string text;
        if (guideItem.type > 0)
        {
            text = Lang.inter[21].Value + " " + guideItem.Name;
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[22].Value, new Vector2(inventoryX, inventoryY + 118), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            int num3 = focusRecipe;
            int num4 = 0;
            for (int i = 0; i < Recipe.maxRequirements; i++)
            {
                int num5 = (i + 1) * 26;
                if (recipe[availableRecipe[num3]].requiredTile[i] == -1)
                {
                    if (i == 0 && !recipe[availableRecipe[num3]].needWater && !recipe[availableRecipe[num3]].needHoney && !recipe[availableRecipe[num3]].needLava && !recipe[availableRecipe[num3]].needSnowBiome && !recipe[availableRecipe[num3]].needGraveyardBiome)
                    {
                        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[23].Value, new Vector2(inventoryX, inventoryY + 118 + num5), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                    }
                    break;
                }
                num4++;
                int num6 = recipe[availableRecipe[num3]].requiredTile[i];
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.GetMapObjectName(MapHelper.TileToLookup(num6, Recipe.GetRequiredTileStyle(num6))), new Vector2(inventoryX, inventoryY + 118 + num5), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (recipe[availableRecipe[num3]].needWater)
            {
                int num7 = (num4 + 1) * 26;
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[53].Value, new Vector2(inventoryX, inventoryY + 118 + num7), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (recipe[availableRecipe[num3]].needHoney)
            {
                int num8 = (num4 + 1) * 26;
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[58].Value, new Vector2(inventoryX, inventoryY + 118 + num8), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (recipe[availableRecipe[num3]].needLava)
            {
                int num9 = (num4 + 1) * 26;
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[56].Value, new Vector2(inventoryX, inventoryY + 118 + num9), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (recipe[availableRecipe[num3]].needSnowBiome)
            {
                int num10 = (num4 + 1) * 26;
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[123].Value, new Vector2(inventoryX, inventoryY + 118 + num10), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (recipe[availableRecipe[num3]].needGraveyardBiome)
            {
                int num11 = (num4 + 1) * 26;
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, Lang.inter[124].Value, new Vector2(inventoryX, inventoryY + 118 + num11), craftingTipColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
        }
        else
        {
            text = Lang.inter[24].Value;
        }
        inventoryX -= num;
        inventoryY -= num2;
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(inventoryX + 50, inventoryY + 12), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
    }
 
    public static void LockCraftingForThisCraftClickDuration()
    {
        _preventCraftingBecauseClickWasUsedToChangeFocusedRecipe = true;
    }
 
    private static void HoverOverCraftingItemButton(int recipeIndex)
    {
        Recipe recipe = Main.recipe[availableRecipe[recipeIndex]];
        player[myPlayer].mouseInterface = true;
        bool flag = (mouseLeftRelease && mouseLeft) || (mouseRightRelease && mouseRight);
        bool flag2 = mouseLeft || mouseRight;
        if (focusRecipe == recipeIndex && guideItem.IsAir)
        {
            bool flag3 = LocalPlayer.ItemTimeIsZero && LocalPlayer.itemAnimation == 0 && !player[myPlayer].HasLockedInventory() && !_preventCraftingBecauseClickWasUsedToChangeFocusedRecipe;
            bool num = _currentRecipeBeingCrafted != -1 && _currentRecipeBeingCrafted != availableRecipe[recipeIndex];
            bool flag4 = _currentRecipeBeingCrafted != -1 && Main.recipe[_currentRecipeBeingCrafted].createItem.maxStack == 1;
            bool flag5 = num || flag4;
            if (flag2 && !flag5 && flag3 && stackSplit <= 1)
            {
                bool usingGamepad = PlayerInput.UsingGamepad;
                bool movedAnItemToAllowCrafting;
                bool num2 = TryAllowingToCraftRecipe(recipe, usingGamepad, out movedAnItemToAllowCrafting);
                if (movedAnItemToAllowCrafting)
                {
                    _preventCraftingBecauseClickWasUsedToChangeFocusedRecipe = true;
                }
                if (num2 && !movedAnItemToAllowCrafting)
                {
                    if (_currentRecipeBeingCrafted == -1)
                    {
                        _currentRecipeBeingCrafted = availableRecipe[recipeIndex];
                    }
                    ItemSlot.RefreshStackSplitCooldown();
                    CraftItem(recipe);
                }
            }
        }
        else if (flag)
        {
            focusRecipe = recipeIndex;
            stackSplit = 15;
            _preventCraftingBecauseClickWasUsedToChangeFocusedRecipe = true;
        }
        craftingHide = true;
        HoverItem = recipe.createItem.Clone();
        ItemSlot.MouseHover(22);
        hoverItemName = recipe.createItem.Name;
        if (recipe.createItem.stack > 1)
        {
            hoverItemName = hoverItemName + " (" + recipe.createItem.stack + ")";
        }
        if (!flag2)
        {
            _preventCraftingBecauseClickWasUsedToChangeFocusedRecipe = false;
            _currentRecipeBeingCrafted = -1;
        }
    }
 
    private static bool TryAllowingToCraftRecipe(Recipe currentRecipe, bool tryFittingItemInInventoryToAllowCrafting, out bool movedAnItemToAllowCrafting)
    {
        movedAnItemToAllowCrafting = false;
        if (mouseItem.IsAir)
        {
            return true;
        }
        if (mouseItem.IsTheSameAs(currentRecipe.createItem) && mouseItem.stack + currentRecipe.createItem.stack <= mouseItem.maxStack)
        {
            return true;
        }
        if (tryFittingItemInInventoryToAllowCrafting && LocalPlayer.ItemSpace(mouseItem).CanTakeItemToPersonalInventory)
        {
            mouseItem = LocalPlayer.GetItem(myPlayer, mouseItem, GetItemSettings.InventoryUIToInventorySettingsShowAsNew);
            if (mouseItem.IsAir)
            {
                movedAnItemToAllowCrafting = true;
                return true;
            }
            if (mouseItem.IsTheSameAs(currentRecipe.createItem) && mouseItem.stack + currentRecipe.createItem.stack <= mouseItem.maxStack)
            {
                movedAnItemToAllowCrafting = true;
                return true;
            }
        }
        return false;
    }
 
    private static void DrawTrashItemSlot(int pivotTopLeftX, int pivotTopLeftY)
    {
        inventoryScale = 0.85f;
        int num = 448 + pivotTopLeftX;
        int num2 = 258 + pivotTopLeftY;
        if ((player[myPlayer].chest != -1 || npcShop > 0) && !recBigList)
        {
            num2 += 168;
            inventoryScale = 0.755f;
            num += 5;
        }
        new Microsoft.Xna.Framework.Color(150, 150, 150, 150);
        if (mouseX >= num && (float)mouseX <= (float)num + (float)TextureAssets.InventoryBack.Width() * inventoryScale && mouseY >= num2 && (float)mouseY <= (float)num2 + (float)TextureAssets.InventoryBack.Height() * inventoryScale && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
            ItemSlot.LeftClick(ref player[myPlayer].trashItem, 6);
            if (mouseLeftRelease && mouseLeft)
            {
                Recipe.FindRecipes();
            }
            ItemSlot.MouseHover(ref player[myPlayer].trashItem, 6);
        }
        ItemSlot.Draw(spriteBatch, ref player[myPlayer].trashItem, 6, new Vector2(num, num2));
    }
 
    private static void DrawEmoteBubblesButton(int pivotTopLeftX, int pivotTopLeftY)
    {
        inventoryScale = 0.85f;
        int num = (int)((float)(450 + pivotTopLeftX) - 56f * inventoryScale);
        int num2 = 258 + pivotTopLeftY;
        int num3 = 244;
        int width = 30;
        int num4 = 30;
        num = 534;
        num2 = num3 + num4 + 4;
        if ((player[myPlayer].chest != -1 || npcShop > 0) && !recBigList)
        {
            num2 += 168;
            inventoryScale = 0.755f;
            num += 5;
            num3 += 24;
        }
        if (editChest)
        {
            num2 += 24;
        }
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(num, num2, (int)((float)TextureAssets.InventoryBack.Width() * inventoryScale), (int)((float)TextureAssets.InventoryBack.Height() * inventoryScale));
        rectangle = new Microsoft.Xna.Framework.Rectangle(num, num2, width, num4);
        bool flag = false;
        if (rectangle.Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)) && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
            flag = true;
            if (mouseLeft && mouseLeftRelease)
            {
                player[myPlayer].SetTalkNPC(-1);
                npcChatCornerItem = 0;
                npcChatText = "";
                mouseLeftRelease = false;
                SoundEngine.PlaySound(12);
                IngameFancyUI.OpenUIState(new UIEmotesMenu());
            }
        }
        Texture2D value = TextureAssets.EmoteMenuButton.Value;
        Vector2 position = rectangle.Center.ToVector2();
        Microsoft.Xna.Framework.Rectangle rectangle2 = value.Frame(2, 1, flag ? 1 : 0);
        rectangle2.Width -= 2;
        rectangle2.Height -= 2;
        Vector2 origin = rectangle2.Size() / 2f;
        Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
        spriteBatch.Draw(value, position, rectangle2, white, 0f, origin, 1f, SpriteEffects.None, 0f);
        UILinkPointNavigator.SetPosition(309, position);
        if (!mouseText && flag)
        {
            instance.MouseText(Language.GetTextValue("GameUI.Emote"), 0, 0);
        }
    }
 
    private static void DrawBestiaryIcon(int pivotTopLeftX, int pivotTopLeftY)
    {
        inventoryScale = 0.85f;
        int num = (int)((float)(450 + pivotTopLeftX) - 56f * inventoryScale * 2f);
        int num2 = 258 + pivotTopLeftY;
        int num3 = 244;
        int width = 30;
        int num4 = 30;
        num3 = 244;
        num = 498;
        num2 = num3 + num4 + 4;
        if ((player[myPlayer].chest != -1 || npcShop > 0) && !recBigList)
        {
            num2 += 168;
            inventoryScale = 0.755f;
            num += 5;
            num3 += 24;
        }
        if (editChest)
        {
            num2 += 24;
        }
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(num, num2, (int)((float)TextureAssets.InventoryBack.Width() * inventoryScale), (int)((float)TextureAssets.InventoryBack.Height() * inventoryScale));
        rectangle = new Microsoft.Xna.Framework.Rectangle(num, num2, width, num4);
        bool flag = false;
        if (rectangle.Contains(new Microsoft.Xna.Framework.Point(mouseX, mouseY)) && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
            flag = true;
            if (mouseLeft && mouseLeftRelease)
            {
                player[myPlayer].SetTalkNPC(-1);
                npcChatCornerItem = 0;
                npcChatText = "";
                mouseLeftRelease = false;
                SoundEngine.PlaySound(12);
                IngameFancyUI.OpenUIState(BestiaryUI);
                BestiaryUI.OnOpenPage();
            }
        }
        Texture2D value = TextureAssets.BestiaryMenuButton.Value;
        Vector2 position = rectangle.Center.ToVector2();
        Microsoft.Xna.Framework.Rectangle rectangle2 = value.Frame(2, 1, flag ? 1 : 0);
        rectangle2.Width -= 2;
        rectangle2.Height -= 2;
        Vector2 origin = rectangle2.Size() / 2f;
        Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
        spriteBatch.Draw(value, position, rectangle2, white, 0f, origin, 1f, SpriteEffects.None, 0f);
        UILinkPointNavigator.SetPosition(310, position);
        if (!mouseText && flag)
        {
            instance.MouseText(Language.GetTextValue("GameUI.Bestiary"), 0, 0);
        }
    }
 
    private static void SetRecipeMaterialDisplayName(int i)
    {
        HoverItem = recipe[availableRecipe[focusRecipe]].requiredItem[i].Clone();
        ItemSlot.MouseHover(22);
        hoverItemName = recipe[availableRecipe[focusRecipe]].requiredItem[i].Name;
        if (recipe[availableRecipe[focusRecipe]].ProcessGroupsForText(recipe[availableRecipe[focusRecipe]].requiredItem[i].type, out var theText))
        {
            HoverItem.SetNameOverride(theText);
        }
        if (recipe[availableRecipe[focusRecipe]].anyIronBar && recipe[availableRecipe[focusRecipe]].requiredItem[i].type == 22)
        {
            HoverItem.SetNameOverride(Lang.misc[37].Value + " " + Lang.GetItemNameValue(22));
        }
        else if (recipe[availableRecipe[focusRecipe]].anyWood && recipe[availableRecipe[focusRecipe]].requiredItem[i].type == 9)
        {
            HoverItem.SetNameOverride(Lang.misc[37].Value + " " + Lang.GetItemNameValue(9));
        }
        else if (recipe[availableRecipe[focusRecipe]].anySand && recipe[availableRecipe[focusRecipe]].requiredItem[i].type == 169)
        {
            HoverItem.SetNameOverride(Lang.misc[37].Value + " " + Lang.GetItemNameValue(169));
        }
        else if (recipe[availableRecipe[focusRecipe]].anyFragment && recipe[availableRecipe[focusRecipe]].requiredItem[i].type == 3458)
        {
            HoverItem.SetNameOverride(Lang.misc[37].Value + " " + Lang.misc[51].Value);
        }
        else if (recipe[availableRecipe[focusRecipe]].anyPressurePlate && recipe[availableRecipe[focusRecipe]].requiredItem[i].type == 542)
        {
            HoverItem.SetNameOverride(Lang.misc[37].Value + " " + Lang.misc[38].Value);
        }
        if (recipe[availableRecipe[focusRecipe]].requiredItem[i].stack > 1)
        {
            hoverItemName = hoverItemName + " (" + recipe[availableRecipe[focusRecipe]].requiredItem[i].stack + ")";
        }
    }
 
    private void DrawHotbarLockIcon(int pivotTopLeftX, int pivotTopLeftY, bool pushSideToolsUp)
    {
        int num = 21 + pivotTopLeftY;
        _ = player[myPlayer];
        if (pushSideToolsUp)
        {
            num = pivotTopLeftY;
        }
        float num2 = 0.9f;
        Texture2D value = TextureAssets.HbLock[(!player[myPlayer].hbLocked) ? 1u : 0u].Value;
        Microsoft.Xna.Framework.Rectangle value2 = value.Frame(2);
        bool flag = false;
        if (mouseX > pivotTopLeftX && (float)mouseX < (float)pivotTopLeftX + (float)value2.Width * num2 && mouseY > num && (float)mouseY < (float)num + (float)value2.Height * num2)
        {
            flag = true;
            player[myPlayer].mouseInterface = true;
            if (!player[myPlayer].hbLocked)
            {
                MouseText(Lang.inter[5].Value, 0, 0);
            }
            else
            {
                MouseText(Lang.inter[6].Value, 0, 0);
            }
            mouseText = true;
            if (mouseLeft && mouseLeftRelease)
            {
                SoundEngine.PlaySound(22);
                player[myPlayer].hbLocked = !player[myPlayer].hbLocked;
            }
        }
        spriteBatch.Draw(value, new Vector2(pivotTopLeftX, num), value2, Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        if (flag)
        {
            spriteBatch.Draw(value, new Vector2(pivotTopLeftX, num), value.Frame(2, 1, 1), OurFavoriteColor, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        }
    }
 
    private void DrawBlockReplacementIcon(int pivotTopLeftX, int pivotTopLeftY, bool pushSideToolsUp, int gamepadPointOffset)
    {
        if (!playerInventory)
        {
            return;
        }
        int num = 44 + pivotTopLeftY;
        _ = player[myPlayer];
        if (pushSideToolsUp)
        {
            num = 23 + pivotTopLeftY;
        }
        float num2 = 0.9f;
        int num3 = 10;
        bool flag = player[myPlayer].builderAccStatus[num3] == 0;
        Texture2D value = TextureAssets.blockReplaceIcon[0].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(3, 1, (!flag) ? 1 : 0);
        bool flag2 = false;
        if (mouseX > pivotTopLeftX && (float)mouseX < (float)pivotTopLeftX + (float)rectangle.Width * num2 && mouseY > num && (float)mouseY < (float)num + (float)rectangle.Height * num2)
        {
            flag2 = true;
            player[myPlayer].mouseInterface = true;
            MouseText(flag ? Language.GetTextValue("GameUI.BlockReplacerOn") : Language.GetTextValue("GameUI.BlockReplacerOff"), 0, 0);
            mouseText = true;
            if (mouseLeft && mouseLeftRelease)
            {
                SoundEngine.PlaySound(22);
                player[myPlayer].builderAccStatus[num3] = (flag ? 1 : 0);
            }
        }
        Vector2 vector = new Vector2(pivotTopLeftX, num);
        spriteBatch.Draw(value, vector, rectangle, Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        if (flag2)
        {
            spriteBatch.Draw(value, vector, value.Frame(3, 1, 2), OurFavoriteColor, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        }
        UILinkPointNavigator.SetPosition(6000 + gamepadPointOffset, vector + rectangle.Size() * 0.65f);
    }
 
    private void DrawTorchBiomeSwapIcon(int pivotTopLeftX, int pivotTopLeftY, bool pushSideToolsUp, int gamepadPointOffset)
    {
        if (!playerInventory)
        {
            return;
        }
        int num = 68 + pivotTopLeftY;
        _ = player[myPlayer];
        if (pushSideToolsUp)
        {
            num = 47 + pivotTopLeftY;
        }
        float num2 = 0.9f;
        int num3 = 11;
        bool flag = player[myPlayer].builderAccStatus[num3] == 0;
        Texture2D value = TextureAssets.Extra[211].Value;
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(4, 1, flag ? 1 : 0);
        bool flag2 = false;
        if (mouseX > pivotTopLeftX && (float)mouseX < (float)pivotTopLeftX + (float)rectangle.Width * num2 && mouseY > num && (float)mouseY < (float)num + (float)rectangle.Height * num2)
        {
            flag2 = true;
            player[myPlayer].mouseInterface = true;
            MouseText(flag ? Language.GetTextValue("GameUI.TorchTypeSwapperOn") : Language.GetTextValue("GameUI.TorchTypeSwapperOff"), 0, 0);
            mouseText = true;
            if (mouseLeft && mouseLeftRelease)
            {
                SoundEngine.PlaySound(22);
                player[myPlayer].builderAccStatus[num3] = (flag ? 1 : 0);
            }
        }
        Vector2 vector = new Vector2(pivotTopLeftX, num);
        spriteBatch.Draw(value, vector, rectangle, Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        if (flag2)
        {
            spriteBatch.Draw(value, vector, value.Frame(4, 1, flag ? 3 : 2), OurFavoriteColor, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        }
        UILinkPointNavigator.SetPosition(6000 + gamepadPointOffset, vector + rectangle.Size() * 0.65f);
    }
 
    public static void CraftItem(Recipe r)
    {
        int stack = mouseItem.stack;
        mouseItem = r.createItem.Clone();
        mouseItem.stack += stack;
        mouseItem.OnCreated(new RecipeItemCreationContext(r));
        if (stack <= 0)
        {
            mouseItem.Prefix(-1);
        }
        mouseItem.position.X = player[myPlayer].position.X + (float)(player[myPlayer].width / 2) - (float)(mouseItem.width / 2);
        mouseItem.position.Y = player[myPlayer].position.Y + (float)(player[myPlayer].height / 2) - (float)(mouseItem.height / 2);
        PopupText.NewText(PopupTextContext.ItemCraft, mouseItem, r.createItem.stack);
        r.Create();
        if (mouseItem.type > 0 || r.createItem.type > 0)
        {
            SoundEngine.PlaySound(7);
        }
    }
 
    private static void DrawPVPIcons()
    {
        if (EquipPage == 1)
        {
            if (hidePVPIcons)
            {
                return;
            }
        }
        else
        {
            hidePVPIcons = false;
        }
        inventoryScale = 0.6f;
        int num = (int)(52f * inventoryScale);
        int num2 = 707 - num * 4 + screenWidth - 800;
        int num3 = 114 + mH + num * 2 + num / 2 - 12;
        if (EquipPage == 2)
        {
            num2 += num + num / 2;
        }
        int num4 = (player[myPlayer].hostile ? 2 : 0);
        if (mouseX > num2 - 7 && mouseX < num2 + 25 && mouseY > num3 - 2 && mouseY < num3 + 37 && !PlayerInput.IgnoreMouseInterface)
        {
            player[myPlayer].mouseInterface = true;
            if (teamCooldown == 0)
            {
                num4++;
            }
            if (mouseLeft && mouseLeftRelease && teamCooldown == 0)
            {
                teamCooldown = teamCooldownLen;
                SoundEngine.PlaySound(12);
                player[myPlayer].hostile = !player[myPlayer].hostile;
                NetMessage.SendData(30, -1, -1, null, myPlayer);
            }
        }
        Microsoft.Xna.Framework.Rectangle rectangle = TextureAssets.Pvp[0].Frame(4, 6);
        rectangle.Location = new Microsoft.Xna.Framework.Point(rectangle.Width * num4, rectangle.Height * player[myPlayer].team);
        rectangle.Width -= 2;
        rectangle.Height--;
        spriteBatch.Draw(TextureAssets.Pvp[0].Value, new Vector2(num2 - 10, num3), rectangle, Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f);
        UILinkPointNavigator.SetPosition(1550, new Vector2(num2 - 10, num3) + rectangle.Size() * 0.75f);
        num3 += 60;
        num2 -= 10;
        rectangle = TextureAssets.Pvp[1].Frame(6);
        Microsoft.Xna.Framework.Rectangle r = rectangle;
        for (int i = 0; i < 6; i++)
        {
            r.Location = new Microsoft.Xna.Framework.Point(num2 + i % 2 * 20, num3 + i / 2 * 20);
            rectangle.X = rectangle.Width * i;
            bool flag = false;
            if (r.Contains(MouseScreen.ToPoint()) && !PlayerInput.IgnoreMouseInterface)
            {
                player[myPlayer].mouseInterface = true;
                if (teamCooldown == 0)
                {
                    flag = true;
                }
                if (mouseLeft && mouseLeftRelease && player[myPlayer].team != i && teamCooldown == 0)
                {
                    if (!player[myPlayer].TeamChangeAllowed())
                    {
                        NewText(Lang.misc[84].Value, byte.MaxValue, 240, 20);
                    }
                    else
                    {
                        teamCooldown = teamCooldownLen;
                        SoundEngine.PlaySound(12);
                        player[myPlayer].team = i;
                        NetMessage.SendData(45, -1, -1, null, myPlayer);
                    }
                }
            }
            r.Width = rectangle.Width - 2;
            if (flag)
            {
                spriteBatch.Draw(TextureAssets.Pvp[2].Value, r.Location.ToVector2() + new Vector2(-2f), Microsoft.Xna.Framework.Color.White);
            }
            Microsoft.Xna.Framework.Rectangle value = rectangle;
            value.Width -= 2;
            spriteBatch.Draw(TextureAssets.Pvp[1].Value, r.Location.ToVector2(), value, Microsoft.Xna.Framework.Color.White);
            UILinkPointNavigator.SetPosition(1550 + i + 1, r.Location.ToVector2() + r.Size() * 0.75f);
        }
    }
 
    private static int DrawPageIcons(int yPos)
    {
        int num = -1;
        Vector2 vector = new Vector2(screenWidth - 162, yPos);
        vector.X += 82f;
        Texture2D value = TextureAssets.EquipPage[(EquipPage == 2) ? 3 : 2].Value;
        if (Collision.CheckAABBvAABBCollision(vector, value.Size(), new Vector2(mouseX, mouseY), Vector2.One) && (mouseItem.stack < 1 || mouseItem.dye > 0))
        {
            num = 2;
        }
        if (num == 2)
        {
            spriteBatch.Draw(TextureAssets.EquipPage[6].Value, vector, null, OurFavoriteColor, 0f, new Vector2(2f), 0.9f, SpriteEffects.None, 0f);
        }
        spriteBatch.Draw(value, vector, null, Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, 0.9f, SpriteEffects.None, 0f);
        UILinkPointNavigator.SetPosition(305, vector + value.Size() * 0.75f);
        vector.X -= 48f;
        value = TextureAssets.EquipPage[(EquipPage == 1) ? 5 : 4].Value;
        if (Collision.CheckAABBvAABBCollision(vector, value.Size(), new Vector2(mouseX, mouseY), Vector2.One) && mouseItem.stack < 1)
        {
            num = 1;
        }
        if (num == 1)
        {
            spriteBatch.Draw(TextureAssets.EquipPage[7].Value, vector, null, OurFavoriteColor, 0f, new Vector2(2f), 0.9f, SpriteEffects.None, 0f);
        }
        spriteBatch.Draw(value, vector, null, Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, 0.9f, SpriteEffects.None, 0f);
        UILinkPointNavigator.SetPosition(306, vector + value.Size() * 0.75f);
        vector.X -= 48f;
        value = TextureAssets.EquipPage[(EquipPage == 3) ? 10 : 8].Value;
        if (Collision.CheckAABBvAABBCollision(vector, value.Size(), new Vector2(mouseX, mouseY), Vector2.One) && mouseItem.stack < 1)
        {
            num = 3;
        }
        if (num == 3 && !CaptureModeDisabled)
        {
            spriteBatch.Draw(TextureAssets.EquipPage[9].Value, vector, null, OurFavoriteColor, 0f, Vector2.Zero, 0.9f, SpriteEffects.None, 0f);
        }
        spriteBatch.Draw(value, vector, null, CaptureModeDisabled ? Microsoft.Xna.Framework.Color.Red : Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, 0.9f, SpriteEffects.None, 0f);
        UILinkPointNavigator.SetPosition(307, vector + value.Size() * 0.75f);
        if (num != -1)
        {
            player[myPlayer].mouseInterface = true;
            if (mouseLeft && mouseLeftRelease)
            {
                bool flag = true;
                if (num == 3)
                {
                    if (CaptureModeDisabled)
                    {
                        flag = false;
                    }
                    else if (PlayerInput.UsingGamepad)
                    {
                        CaptureInterface.QuickScreenshot();
                    }
                    else
                    {
                        CaptureManager.Instance.Active = true;
                        blockMouse = true;
                    }
                }
                else if (EquipPageSelected != num)
                {
                    EquipPageSelected = num;
                }
                else
                {
                    EquipPageSelected = 0;
                }
                if (flag)
                {
                    SoundEngine.PlaySound(10);
                }
            }
        }
        ItemSlot.SelectEquipPage(mouseItem);
        if (EquipPage == -1)
        {
            EquipPage = EquipPageSelected;
        }
        return num;
    }
 
    public void DrawMouseOver()
    {
        PlayerInput.SetZoom_Unscaled();
        PlayerInput.SetZoom_MouseInWorld();
        Microsoft.Xna.Framework.Rectangle mouseRectangle = new Microsoft.Xna.Framework.Rectangle((int)((float)mouseX + screenPosition.X), (int)((float)mouseY + screenPosition.Y), 1, 1);
        if (player[myPlayer].gravDir == -1f)
        {
            mouseRectangle.Y = (int)screenPosition.Y + screenHeight - mouseY;
        }
        PlayerInput.SetZoom_UI();
        if (!LocalPlayer.ghost)
        {
            ResourceSetsManager.TryToHoverOverResources();
        }
        AchievementAdvisor.DrawMouseHover();
        IngameOptions.MouseOver();
        IngameFancyUI.MouseOver();
        if (!mouseText)
        {
            for (int i = 0; i < 400; i++)
            {
                if (!item[i].active)
                {
                    continue;
                }
                Microsoft.Xna.Framework.Rectangle drawHitbox = Item.GetDrawHitbox(item[i].type, null);
                Vector2 bottom = item[i].Bottom;
                Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle((int)(bottom.X - (float)drawHitbox.Width * 0.5f), (int)(bottom.Y - (float)drawHitbox.Height), drawHitbox.Width, drawHitbox.Height);
                if (mouseRectangle.Intersects(value))
                {
                    player[myPlayer].cursorItemIconEnabled = false;
                    string text = item[i].AffixName();
                    if (item[i].stack > 1)
                    {
                        text = text + " (" + item[i].stack + ")";
                    }
                    if (item[i].playerIndexTheItemIsReservedFor < 255 && showItemOwner)
                    {
                        text = text + " <" + player[item[i].playerIndexTheItemIsReservedFor].name + ">";
                    }
                    rare = item[i].rare;
                    if (item[i].expert)
                    {
                        rare = -12;
                    }
                    MouseTextHackZoom(text, rare, 0);
                    mouseText = true;
                    break;
                }
            }
        }
        for (int j = 0; j < 255; j++)
        {
            if (!player[j].active || myPlayer == j || player[j].dead || player[j].ShouldNotDraw || !((double)player[j].stealth > 0.5))
            {
                continue;
            }
            Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle((int)((double)player[j].position.X + (double)player[j].width * 0.5 - 16.0), (int)(player[j].position.Y + (float)player[j].height - 48f), 32, 48);
            if (!mouseText && mouseRectangle.Intersects(value2))
            {
                player[myPlayer].cursorItemIconEnabled = false;
                int num = player[j].statLife;
                if (num < 0)
                {
                    num = 0;
                }
                string text2 = player[j].name + ": " + num + "/" + player[j].statLifeMax2;
                if (player[j].hostile)
                {
                    text2 = text2 + " " + Language.GetTextValue("Game.PvPFlag");
                }
                MouseTextHackZoom(text2, 0, player[j].difficulty);
                mouseText = true;
            }
        }
        HoveringOverAnNPC = false;
        if (!mouseText)
        {
            HoverOverNPCs(mouseRectangle);
        }
        if (!mouseText && signHover != -1 && sign[signHover] != null && !player[myPlayer].mouseInterface && !string.IsNullOrWhiteSpace(sign[signHover].text))
        {
            int lineAmount;
            string[] array = Utils.WordwrapString(sign[signHover].text, FontAssets.MouseText.Value, 460, 10, out lineAmount);
            lineAmount++;
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, _uiScaleMatrix);
            PlayerInput.SetZoom_UI();
            int num2 = screenWidth;
            int num3 = screenHeight;
            int num4 = mouseX;
            int num5 = mouseY;
            PlayerInput.SetZoom_UI();
            PlayerInput.SetZoom_Test();
            float num6 = 0f;
            for (int k = 0; k < lineAmount; k++)
            {
                float x = FontAssets.MouseText.Value.MeasureString(array[k]).X;
                if (num6 < x)
                {
                    num6 = x;
                }
            }
            if (num6 > 460f)
            {
                num6 = 460f;
            }
            bool settingsEnabled_OpaqueBoxBehindTooltips = SettingsEnabled_OpaqueBoxBehindTooltips;
            Vector2 vector = new Vector2(num4, num5) + new Vector2(16f);
            if (settingsEnabled_OpaqueBoxBehindTooltips)
            {
                vector += new Vector2(8f, 2f);
            }
            if (vector.Y > (float)(num3 - 30 * lineAmount))
            {
                vector.Y = num3 - 30 * lineAmount;
            }
            if (vector.X > (float)num2 - num6)
            {
                vector.X = (float)num2 - num6;
            }
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
            if (settingsEnabled_OpaqueBoxBehindTooltips)
            {
                color = Microsoft.Xna.Framework.Color.Lerp(color, Microsoft.Xna.Framework.Color.White, 1f);
                int num7 = 10;
                int num8 = 5;
                Utils.DrawInvBG(spriteBatch, new Microsoft.Xna.Framework.Rectangle((int)vector.X - num7, (int)vector.Y - num8, (int)num6 + num7 * 2, 30 * lineAmount + num8 + num8 / 2), new Microsoft.Xna.Framework.Color(23, 25, 81, 255) * 0.925f * 0.85f);
            }
            for (int l = 0; l < lineAmount; l++)
            {
                Utils.DrawBorderStringFourWay(spriteBatch, FontAssets.MouseText.Value, array[l], vector.X, vector.Y + (float)(l * 30), color, Microsoft.Xna.Framework.Color.Black, Vector2.Zero);
            }
            mouseText = true;
        }
        PlayerInput.SetZoom_UI();
    }
 
    private void HoverOverNPCs(Microsoft.Xna.Framework.Rectangle mouseRectangle)
    {
        Player player = Main.player[myPlayer];
        for (int i = 0; i < 200; i++)
        {
            NPC nPC = npc[i];
            if (!(nPC.active & (nPC.shimmerTransparency == 0f || nPC.CanApplyHunterPotionEffects())))
            {
                continue;
            }
            int type = nPC.type;
            LoadNPC(type);
            nPC.position += nPC.netOffset;
            Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle((int)nPC.Bottom.X - nPC.frame.Width / 2, (int)nPC.Bottom.Y - nPC.frame.Height, nPC.frame.Width, nPC.frame.Height);
            if (nPC.type >= 87 && nPC.type <= 92)
            {
                value = new Microsoft.Xna.Framework.Rectangle((int)((double)nPC.position.X + (double)nPC.width * 0.5 - 32.0), (int)((double)nPC.position.Y + (double)nPC.height * 0.5 - 32.0), 64, 64);
            }
            bool flag = mouseRectangle.Intersects(value);
            bool flag2 = flag || (SmartInteractShowingGenuine && SmartInteractNPC == i);
            if (flag2 && ((nPC.type != 85 && nPC.type != 341 && nPC.type != 629 && nPC.aiStyle != 87) || nPC.ai[0] != 0f) && nPC.type != 488)
            {
                if (nPC.type == 685)
                {
                    player.cursorItemIconEnabled = true;
                    player.cursorItemIconID = 327;
                    player.cursorItemIconText = "";
                    player.noThrow = 2;
                    if (!player.dead)
                    {
                        PlayerInput.SetZoom_MouseInWorld();
                        if (mouseRight && npcChatRelease)
                        {
                            npcChatRelease = false;
                            if (PlayerInput.UsingGamepad)
                            {
                                player.releaseInventory = false;
                            }
                            if (player.talkNPC != i && !player.tileInteractionHappened && TryFreeingElderSlime(i))
                            {
                                NPC.TransformElderSlime(i);
                                SoundEngine.PlaySound(22);
                            }
                        }
                    }
                }
                else
                {
                    bool flag3 = SmartInteractShowingGenuine && SmartInteractNPC == i;
                    if (nPC.townNPC || nPC.type == 105 || nPC.type == 106 || nPC.type == 123 || nPC.type == 354 || nPC.type == 376 || nPC.type == 579 || nPC.type == 453 || nPC.type == 589)
                    {
                        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle((int)(player.position.X + (float)(player.width / 2) - (float)(Player.tileRangeX * 16)), (int)(player.position.Y + (float)(player.height / 2) - (float)(Player.tileRangeY * 16)), Player.tileRangeX * 16 * 2, Player.tileRangeY * 16 * 2);
                        Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle((int)nPC.position.X, (int)nPC.position.Y, nPC.width, nPC.height);
                        if (rectangle.Intersects(value2))
                        {
                            flag3 = true;
                        }
                    }
                    if (player.ownedProjectileCounts[651] > 0)
                    {
                        flag3 = false;
                    }
                    if (flag3 && !player.dead)
                    {
                        PlayerInput.SetZoom_MouseInWorld();
                        HoveringOverAnNPC = true;
                        currentNPCShowingChatBubble = i;
                        if (mouseRight && npcChatRelease)
                        {
                            npcChatRelease = false;
                            if (PlayerInput.UsingGamepad)
                            {
                                player.releaseInventory = false;
                            }
                            if (player.talkNPC != i && !player.tileInteractionHappened)
                            {
                                CancelHairWindow();
                                SetNPCShopIndex(0);
                                InGuideCraftMenu = false;
                                player.dropItemCheck();
                                npcChatCornerItem = 0;
                                player.sign = -1;
                                editSign = false;
                                player.SetTalkNPC(i);
                                playerInventory = false;
                                player.chest = -1;
                                Recipe.FindRecipes();
                                npcChatText = nPC.GetChat();
                                SoundEngine.PlaySound(24);
                            }
                        }
                    }
                    if (flag && !player.mouseInterface)
                    {
                        player.cursorItemIconEnabled = false;
                        string text = nPC.GivenOrTypeName;
                        int num = i;
                        if (nPC.realLife >= 0)
                        {
                            num = nPC.realLife;
                        }
                        if (npc[num].lifeMax > 1 && !npc[num].dontTakeDamage)
                        {
                            text = text + ": " + npc[num].life + "/" + npc[num].lifeMax;
                        }
                        MouseTextHackZoom(text);
                        mouseText = true;
                        nPC.position -= nPC.netOffset;
                        break;
                    }
                    if (flag2)
                    {
                        nPC.position -= nPC.netOffset;
                        break;
                    }
                }
            }
            nPC.position -= nPC.netOffset;
        }
    }
 
    private static bool TryFreeingElderSlime(int npcIndex)
    {
        Player player = Main.player[myPlayer];
        short type = 327;
        bool inVoidBag = false;
        int num = player.FindItemInInventoryOrOpenVoidBag(type, out inVoidBag);
        if (num == -1)
        {
            return false;
        }
        Item item = null;
        item = ((!inVoidBag) ? player.inventory[num] : player.bank4.item[num]);
        if (--item.stack <= 0)
        {
            item.TurnToAir();
        }
        Recipe.FindRecipes();
        return true;
    }
 
    private static void DrawNPCChatBubble(int i)
    {
        int num = -(npc[i].width / 2 + 8);
        float num2 = npc[i].position.Y - (float)TextureAssets.Chat.Height() - (float)(int)screenPosition.Y;
        if (npc[i].type == 637 && npc[i].ai[0] == 5f)
        {
            num2 -= 18f;
        }
        SpriteEffects spriteEffects = SpriteEffects.None;
        if (npc[i].spriteDirection == -1)
        {
            spriteEffects = SpriteEffects.FlipHorizontally;
            num = npc[i].width / 2 + 8;
        }
        if (player[myPlayer].gravDir != 1f)
        {
            spriteEffects |= SpriteEffects.FlipVertically;
            num2 = (float)screenHeight - num2 - (float)TextureAssets.Chat.Height();
        }
        Vector2 position = new Vector2(npc[i].position.X + (float)(npc[i].width / 2) - screenPosition.X - (float)(TextureAssets.Chat.Width() / 2) - (float)num, num2);
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, null, null, null, GameViewMatrix.ZoomMatrix);
        PlayerInput.SetZoom_UI();
        spriteBatch.Draw(TextureAssets.Chat.Value, position, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chat.Width(), TextureAssets.Chat.Height()), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 1f, spriteEffects, 0f);
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, _uiScaleMatrix);
    }
 
    public void GUIBarsDraw()
    {
        if (ignoreErrors)
        {
            try
            {
                GUIBarsDrawInner();
                return;
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                return;
            }
        }
        GUIBarsDrawInner();
    }
 
    protected void GUIBarsDrawInner()
    {
        ResourceSetsManager.Draw();
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
        DrawInterface_Resources_Breath();
        DrawInterface_Resources_ClearBuffs();
        if (!ingameOptionsWindow && !playerInventory && !inFancyUI)
        {
            DrawInterface_Resources_Buffs();
        }
    }
 
    public static void DrawInterface_Resources_ClearBuffs()
    {
        buffString = "";
        bannerMouseOver = false;
        if (!recBigList)
        {
            recStart = 0;
        }
    }
 
    public void DrawInterface_Resources_Buffs()
    {
        recBigList = false;
        int num = -1;
        int num2 = 11;
        for (int i = 0; i < Player.maxBuffs; i++)
        {
            if (player[myPlayer].buffType[i] > 0)
            {
                _ = player[myPlayer].buffType[i];
                int x = 32 + i * 38;
                int num3 = 76;
                int num4 = i;
                while (num4 >= num2)
                {
                    num4 -= num2;
                    x = 32 + num4 * 38;
                    num3 += 50;
                }
                num = DrawBuffIcon(num, i, x, num3);
            }
            else
            {
                buffAlpha[i] = 0.4f;
            }
        }
        if (num < 0)
        {
            return;
        }
        int num5 = player[myPlayer].buffType[num];
        if (num5 > 0)
        {
            string buffName = Lang.GetBuffName(num5);
            string buffTooltip = GetBuffTooltip(player[myPlayer], num5);
            if (num5 == 147)
            {
                bannerMouseOver = true;
            }
            if (meleeBuff[num5])
            {
                MouseTextHackZoom(buffName, -10, 0, buffTooltip);
            }
            else
            {
                MouseTextHackZoom(buffName, buffTooltip);
            }
        }
    }
 
    public static string GetBuffTooltip(Player player, int buffType)
    {
        string text = Lang.GetBuffDescription(buffType);
        switch (buffType)
        {
        case 26:
            if (expertMode)
            {
                text = Language.GetTextValue("BuffDescription.WellFed_Expert");
            }
            break;
        case 206:
            if (expertMode)
            {
                text = Language.GetTextValue("BuffDescription.WellFed2_Expert");
            }
            break;
        case 207:
            if (expertMode)
            {
                text = Language.GetTextValue("BuffDescription.WellFed3_Expert");
            }
            break;
        case 94:
        {
            int num = (int)(player.manaSickReduction * 100f) + 1;
            text = text + num + "%";
            break;
        }
        }
        return text;
    }
 
    public static bool TryGetBuffTime(int buffSlotOnPlayer, out int buffTimeValue)
    {
        int num = player[myPlayer].buffType[buffSlotOnPlayer];
        buffTimeValue = 0;
        if (!vanityPet[num] && !lightPet[num] && !buffNoTimeDisplay[num] && (!player[myPlayer].honeyWet || num != 48) && (!player[myPlayer].wet || !expertMode || num != 46))
        {
            buffTimeValue = player[myPlayer].buffTime[buffSlotOnPlayer];
            return true;
        }
        return false;
    }
 
    public static int DrawBuffIcon(int drawBuffText, int buffSlotOnPlayer, int x, int y)
    {
        int num = player[myPlayer].buffType[buffSlotOnPlayer];
        if (num == 0)
        {
            return drawBuffText;
        }
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(buffAlpha[buffSlotOnPlayer], buffAlpha[buffSlotOnPlayer], buffAlpha[buffSlotOnPlayer], buffAlpha[buffSlotOnPlayer]);
        spriteBatch.Draw(TextureAssets.Buff[num].Value, new Vector2(x, y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Buff[num].Width(), TextureAssets.Buff[num].Height()), color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        if (TryGetBuffTime(buffSlotOnPlayer, out var buffTimeValue) && buffTimeValue > 2)
        {
            string text = Lang.LocalizedDuration(new TimeSpan(0, 0, buffTimeValue / 60), abbreviated: true, showAllAvailableUnits: false);
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.ItemStack.Value, text, new Vector2(x, y + TextureAssets.Buff[num].Height()), color, 0f, default(Vector2), 0.8f, SpriteEffects.None, 0f);
        }
        if (mouseX < x + TextureAssets.Buff[num].Width() && mouseY < y + TextureAssets.Buff[num].Height() && mouseX > x && mouseY > y)
        {
            drawBuffText = buffSlotOnPlayer;
            buffAlpha[buffSlotOnPlayer] += 0.1f;
            bool flag = mouseRight && mouseRightRelease;
            if (PlayerInput.UsingGamepad)
            {
                flag = mouseLeft && mouseLeftRelease && playerInventory;
                if (playerInventory)
                {
                    player[myPlayer].mouseInterface = true;
                }
            }
            else
            {
                player[myPlayer].mouseInterface = true;
            }
            if (flag)
            {
                TryRemovingBuff(buffSlotOnPlayer, num);
            }
        }
        else
        {
            buffAlpha[buffSlotOnPlayer] -= 0.05f;
        }
        if (buffAlpha[buffSlotOnPlayer] > 1f)
        {
            buffAlpha[buffSlotOnPlayer] = 1f;
        }
        else if ((double)buffAlpha[buffSlotOnPlayer] < 0.4)
        {
            buffAlpha[buffSlotOnPlayer] = 0.4f;
        }
        if (PlayerInput.UsingGamepad && !playerInventory)
        {
            drawBuffText = -1;
        }
        return drawBuffText;
    }
 
    public static void TryRemovingBuff(int i, int b)
    {
        bool flag = false;
        if (!debuff[b] && b != 60 && b != 151)
        {
            if (player[myPlayer].mount.Active && player[myPlayer].mount.CheckBuff(b))
            {
                player[myPlayer].mount.Dismount(player[myPlayer]);
                flag = true;
            }
            TryRemovingBuff_CheckBuffHideMisc(0, b);
            TryRemovingBuff_CheckBuffHideMisc(1, b);
            SoundEngine.PlaySound(12);
            if (!flag)
            {
                player[myPlayer].DelBuff(i);
            }
        }
    }
 
    public static void TryRemovingBuff_CheckBuffHideMisc(int slot, int buffID)
    {
        if (!player[myPlayer].hideMisc[slot])
        {
            bool flag = player[myPlayer].miscEquips[slot].buffType == buffID;
            if (!flag && (buffID == 102 || buffID == 101))
            {
                flag = player[myPlayer].miscEquips[slot].buffType == 27;
            }
            if (flag)
            {
                player[myPlayer].hideMisc[slot] = true;
            }
        }
    }
 
    private static void DrawInterface_Resources_Breath()
    {
        bool flag = false;
        if (player[myPlayer].dead)
        {
            return;
        }
        if (player[myPlayer].lavaTime < player[myPlayer].lavaMax && player[myPlayer].lavaWet)
        {
            flag = true;
        }
        else if (player[myPlayer].lavaTime < player[myPlayer].lavaMax && player[myPlayer].breath == player[myPlayer].breathMax)
        {
            flag = true;
        }
        Vector2 vector = player[myPlayer].Top + new Vector2(0f, player[myPlayer].gfxOffY);
        if (playerInventory && screenHeight < 1000)
        {
            vector.Y += player[myPlayer].height - 20;
        }
        vector = Vector2.Transform(vector - screenPosition, GameViewMatrix.ZoomMatrix);
        if (!playerInventory || screenHeight >= 1000)
        {
            vector.Y -= 100f;
        }
        vector /= UIScale;
        if (ingameOptionsWindow || InGameUI.IsVisible)
        {
            vector = new Vector2(screenWidth / 2, screenHeight / 2 + 236);
            if (InGameUI.IsVisible)
            {
                vector.Y = screenHeight - 64;
            }
        }
        if (player[myPlayer].breath < player[myPlayer].breathMax && !player[myPlayer].ghost && !flag)
        {
            _ = player[myPlayer].breathMax / 20;
            int num = 20;
            for (int i = 1; i < player[myPlayer].breathMax / num + 1; i++)
            {
                int num2 = 255;
                float num3 = 1f;
                if (player[myPlayer].breath >= i * num)
                {
                    num2 = 255;
                }
                else
                {
                    float num4 = (float)(player[myPlayer].breath - (i - 1) * num) / (float)num;
                    num2 = (int)(30f + 225f * num4);
                    if (num2 < 30)
                    {
                        num2 = 30;
                    }
                    num3 = num4 / 4f + 0.75f;
                    if ((double)num3 < 0.75)
                    {
                        num3 = 0.75f;
                    }
                }
                int num5 = 0;
                int num6 = 0;
                if (i > 10)
                {
                    num5 -= 260;
                    num6 += 26;
                }
                spriteBatch.Draw(TextureAssets.Bubble.Value, vector + new Vector2((float)(26 * (i - 1) + num5) - 125f, 32f + ((float)TextureAssets.Bubble.Height() - (float)TextureAssets.Bubble.Height() * num3) / 2f + (float)num6), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Bubble.Width(), TextureAssets.Bubble.Height()), new Microsoft.Xna.Framework.Color(num2, num2, num2, num2), 0f, default(Vector2), num3, SpriteEffects.None, 0f);
            }
        }
        if (!(player[myPlayer].lavaTime < player[myPlayer].lavaMax && !player[myPlayer].ghost && flag))
        {
            return;
        }
        int num7 = player[myPlayer].lavaMax / 10;
        _ = player[myPlayer].breathMax / num7;
        for (int j = 1; j < player[myPlayer].lavaMax / num7 + 1; j++)
        {
            int num8 = 255;
            float num9 = 1f;
            if (player[myPlayer].lavaTime >= j * num7)
            {
                num8 = 255;
            }
            else
            {
                float num10 = (float)(player[myPlayer].lavaTime - (j - 1) * num7) / (float)num7;
                num8 = (int)(30f + 225f * num10);
                if (num8 < 30)
                {
                    num8 = 30;
                }
                num9 = num10 / 4f + 0.75f;
                if ((double)num9 < 0.75)
                {
                    num9 = 0.75f;
                }
            }
            int num11 = 0;
            int num12 = 0;
            if (j > 10)
            {
                num11 -= 260;
                num12 += 26;
            }
            spriteBatch.Draw(TextureAssets.Flame.Value, vector + new Vector2((float)(26 * (j - 1) + num11) - 125f, 32f + ((float)TextureAssets.Flame.Height() - (float)TextureAssets.Flame.Height() * num9) / 2f + (float)num12), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Bubble.Width(), TextureAssets.Bubble.Height()), new Microsoft.Xna.Framework.Color(num8, num8, num8, num8), 0f, default(Vector2), num9, SpriteEffects.None, 0f);
        }
    }
 
    private static void DrawInterface_Resources_GolfPower()
    {
        Projectile projectile = null;
        for (int i = 0; i < 1000; i++)
        {
            Projectile projectile2 = Main.projectile[i];
            if (projectile2.active && projectile2.owner == myPlayer && projectile2.type == 722)
            {
                projectile = projectile2;
                break;
            }
        }
        if (projectile == null)
        {
            return;
        }
        Projectile projectile3 = GolfHelper.FindGolfBallForHelper(projectile);
        if (projectile3 != null)
        {
            float relativeStrength = GolfHelper.CalculateShotStrength(projectile, projectile3).RelativeStrength;
            if (!(relativeStrength < 0.001f))
            {
                Vector2 position = LocalPlayer.Bottom - Camera.ScaledPosition;
                position *= GameViewMatrix.Zoom;
                position /= UIScale;
                position.X -= 27f;
                position.Y += 14f;
                spriteBatch.Draw(TextureAssets.GolfSwingBarPanel.Value, position, null, Microsoft.Xna.Framework.Color.White);
                spriteBatch.Draw(TextureAssets.GolfSwingBarFill.Value, position, new Microsoft.Xna.Framework.Rectangle(0, 0, (int)(54f * relativeStrength), 14), Microsoft.Xna.Framework.Color.White);
            }
        }
    }
 
    private static void DrawInterface_GolfBallIndicator()
    {
        if (!Item.IsAGolfingItem(LocalPlayer.HeldItem))
        {
            return;
        }
        Projectile lastHitBall = LocalGolfState.GetLastHitBall();
        if (lastHitBall != null && GolfHelper.IsGolfBallResting(lastHitBall))
        {
            Vector2 vector = lastHitBall.Top - Camera.ScaledPosition;
            vector *= GameViewMatrix.Zoom;
            vector /= UIScale;
            float num = MathHelper.Clamp(((LocalPlayer.position - lastHitBall.position).Length() - 150f) / 50f, 0f, 1f);
            Vector2 vector2 = Vector2.Clamp(vector, new Vector2(20f), Camera.UnscaledSize - new Vector2(20f));
            float num2 = 0f;
            if (vector2 != vector)
            {
                num2 = (vector2 - vector).ToRotation() + (float)Math.PI / 2f;
            }
            vector2 -= (num2 + (float)Math.PI / 2f).ToRotationVector2() * (((float)Math.Sin(GlobalTimeWrappedHourly * 4f) * 0.5f + 0.5f) * 5f + 14f);
            Texture2D value = TextureAssets.GolfBallArrow.Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(2);
            Vector2 origin = rectangle.Size() * new Vector2(0.5f, 1f);
            Microsoft.Xna.Framework.Rectangle value2 = value.Frame(2, 1, 1);
            spriteBatch.Draw(TextureAssets.GolfBallArrowShadow.Value, vector2 + new Vector2(-4f, 4f) * 1.5f, rectangle, Microsoft.Xna.Framework.Color.White * num, num2, origin, 1.5f, SpriteEffects.None, 0f);
            float amount = (float)Math.Sin(GlobalTimeWrappedHourly * 4f) * 0.5f + 0.5f;
            for (float num3 = 0f; num3 < 1f; num3 += 0.25f)
            {
                spriteBatch.Draw(value, vector2 + ((float)Math.PI * 2f * num3 + num2).ToRotationVector2() * MathHelper.Lerp(2f, 2f, amount), value2, Microsoft.Xna.Framework.Color.Black * num * MathHelper.Lerp(1f, 1f, amount), num2, origin, 1.5f, SpriteEffects.None, 0f);
            }
            for (float num4 = 0f; num4 < 1f; num4 += 0.25f)
            {
                spriteBatch.Draw(value, vector2 + ((float)Math.PI * 2f * num4 + num2).ToRotationVector2() * MathHelper.Lerp(0f, 0f, amount), value2, Microsoft.Xna.Framework.Color.White * num * MathHelper.Lerp(0.8f, 0.8f, amount), num2, origin, 1.5f, SpriteEffects.None, 0f);
            }
            spriteBatch.Draw(value, vector2, rectangle, mouseColor * num, num2, origin, 1.5f, SpriteEffects.None, 0f);
        }
    }
 
    protected void GUIHotbarDrawInner()
    {
        if (playerInventory || player[myPlayer].ghost)
        {
            return;
        }
        string text = Lang.inter[37].Value;
        if (player[myPlayer].inventory[player[myPlayer].selectedItem].Name != null && player[myPlayer].inventory[player[myPlayer].selectedItem].Name != "")
        {
            text = player[myPlayer].inventory[player[myPlayer].selectedItem].AffixName();
        }
        Vector2 vector = FontAssets.MouseText.Value.MeasureString(text) / 2f;
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(236f - vector.X, 0f), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        int num = 20;
        for (int i = 0; i < 10; i++)
        {
            if (i == player[myPlayer].selectedItem)
            {
                if (hotbarScale[i] < 1f)
                {
                    hotbarScale[i] += 0.05f;
                }
            }
            else if ((double)hotbarScale[i] > 0.75)
            {
                hotbarScale[i] -= 0.05f;
            }
            float num2 = hotbarScale[i];
            int num3 = (int)(20f + 22f * (1f - num2));
            int a = (int)(75f + 150f * num2);
            Microsoft.Xna.Framework.Color lightColor = new Microsoft.Xna.Framework.Color(255, 255, 255, a);
            if (!player[myPlayer].hbLocked && !PlayerInput.IgnoreMouseInterface && mouseX >= num && (float)mouseX <= (float)num + (float)TextureAssets.InventoryBack.Width() * hotbarScale[i] && mouseY >= num3 && (float)mouseY <= (float)num3 + (float)TextureAssets.InventoryBack.Height() * hotbarScale[i] && !player[myPlayer].channel)
            {
                player[myPlayer].mouseInterface = true;
                player[myPlayer].cursorItemIconEnabled = false;
                if (mouseLeft && !player[myPlayer].hbLocked && !blockMouse)
                {
                    player[myPlayer].changeItem = i;
                }
                hoverItemName = player[myPlayer].inventory[i].AffixName();
                if (player[myPlayer].inventory[i].stack > 1)
                {
                    hoverItemName = hoverItemName + " (" + player[myPlayer].inventory[i].stack + ")";
                }
                rare = player[myPlayer].inventory[i].rare;
            }
            float num4 = inventoryScale;
            inventoryScale = num2;
            ItemSlot.Draw(spriteBatch, player[myPlayer].inventory, 13, i, new Vector2(num, num3), lightColor);
            inventoryScale = num4;
            num += (int)((float)TextureAssets.InventoryBack.Width() * hotbarScale[i]) + 4;
        }
        int selectedItem = player[myPlayer].selectedItem;
        if (selectedItem >= 10 && (selectedItem != 58 || mouseItem.type > 0))
        {
            float num5 = 1f;
            int num6 = (int)(20f + 22f * (1f - num5));
            int a2 = (int)(75f + 150f * num5);
            Microsoft.Xna.Framework.Color lightColor2 = new Microsoft.Xna.Framework.Color(255, 255, 255, a2);
            float num7 = inventoryScale;
            inventoryScale = num5;
            ItemSlot.Draw(spriteBatch, player[myPlayer].inventory, 13, selectedItem, new Vector2(num, num6), lightColor2);
            inventoryScale = num7;
        }
    }
 
    public static void OpenHairWindow()
    {
        hBar = -1f;
        lBar = -1f;
        sBar = -1f;
        playerInventory = false;
        npcChatText = "";
        oldHairStyle = player[myPlayer].hair;
        oldHairColor = player[myPlayer].hairColor;
        hairWindow = true;
        SoundEngine.PlaySound(10);
    }
 
    public static void CancelHairWindow()
    {
        if (hairWindow)
        {
            player[myPlayer].hair = oldHairStyle;
            player[myPlayer].hairColor = oldHairColor;
            hairWindow = false;
            if (player[myPlayer].talkNPC > -1 && npc[player[myPlayer].talkNPC].type == 353)
            {
                player[myPlayer].SetTalkNPC(-1);
            }
            SoundEngine.PlaySound(11);
        }
    }
 
    public static void BuyHairWindow()
    {
        SoundEngine.PlaySound(18);
        hairWindow = false;
        player[myPlayer].SetTalkNPC(-1);
        npcChatCornerItem = 0;
        NetMessage.SendData(4, -1, -1, null, myPlayer);
    }
 
    public static int UnlockedMaxHair()
    {
        int num = 154;
        if (NPC.downedMartians)
        {
            num += 10;
        }
        if (NPC.downedMartians && NPC.downedMoonlord)
        {
            num++;
        }
        return num;
    }
 
    protected void DrawHairWindow()
    {
        if (npcChatText != "" || playerInventory || player[myPlayer].chest != -1 || npcShop != 0 || player[myPlayer].talkNPC == -1 || InGuideCraftMenu)
        {
            CancelHairWindow();
            return;
        }
        Hairstyles.UpdateUnlocks();
        int count = Hairstyles.AvailableHairstyles.Count;
        int num = screenHeight / 2 + 60;
        int num2 = screenWidth / 2 - TextureAssets.HairStyleBack.Width() / 2;
        int num3 = num + 42;
        int num4 = num2 + 22;
        int num5 = num2 + 234;
        int num6 = num + 18;
        selColor = player[myPlayer].hairColor;
        spriteBatch.Draw(TextureAssets.HairStyleBack.Value, new Vector2(num2, num), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.HairStyleBack.Width(), TextureAssets.HairStyleBack.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        if (new Microsoft.Xna.Framework.Rectangle(num2, num, TextureAssets.HairStyleBack.Width(), TextureAssets.HairStyleBack.Height()).Contains(MouseScreen.ToPoint()))
        {
            int num7 = PlayerInput.ScrollWheelDelta / 120;
            num7 = -num7;
            int num8 = Math.Sign(num7);
            while (num7 != 0)
            {
                if (num7 < 0)
                {
                    hairStart -= 5;
                    SoundEngine.PlaySound(12);
                }
                else
                {
                    hairStart += 5;
                    SoundEngine.PlaySound(12);
                }
                num7 -= num8;
            }
        }
        if (mouseX > num2 && mouseX < num2 + TextureAssets.HairStyleBack.Width() && mouseY > num && mouseY < num + TextureAssets.HairStyleBack.Height())
        {
            player[myPlayer].mouseInterface = true;
        }
        int num9 = num5 - 18;
        int num10 = num6 + 74;
        if (hairStart > 1)
        {
            if (mouseX >= num9 && mouseX <= num9 + TextureAssets.CraftUpButton.Width() && mouseY >= num10 && mouseY <= num10 + TextureAssets.CraftUpButton.Height())
            {
                player[myPlayer].mouseInterface = true;
                if (mouseLeftRelease && mouseLeft)
                {
                    hairStart -= 15;
                    SoundEngine.PlaySound(12);
                }
            }
            spriteBatch.Draw(TextureAssets.ScrollLeftButton.Value, new Vector2(num9, num10), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.CraftUpButton.Width(), TextureAssets.CraftUpButton.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        if (hairStart + 15 < count)
        {
            num9 += 296;
            if (mouseX >= num9 && mouseX <= num9 + TextureAssets.CraftUpButton.Width() && mouseY >= num10 && mouseY <= num10 + TextureAssets.CraftUpButton.Height())
            {
                player[myPlayer].mouseInterface = true;
                if (mouseLeftRelease && mouseLeft)
                {
                    hairStart += 15;
                    SoundEngine.PlaySound(12);
                }
            }
            spriteBatch.Draw(TextureAssets.ScrollRightButton.Value, new Vector2(num9, num10), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.CraftUpButton.Width(), TextureAssets.CraftUpButton.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        if (hairStart + 15 >= count)
        {
            hairStart = count - 15;
        }
        if (hairStart < 0)
        {
            hairStart = 0;
        }
        int num11 = 0;
        if (oldHairStyle != player[myPlayer].hair)
        {
            num11 += 100000;
        }
        if (oldHairColor != player[myPlayer].hairColor)
        {
            num11 += 20000;
        }
        num11 = (int)((double)num11 * player[myPlayer].currentShoppingSettings.PriceAdjustment);
        num11 = (int)Math.Round((float)num11 / 10000f) * 10000;
        string text = "";
        string text2 = "";
        int num12 = 0;
        int num13 = 0;
        int num14 = 0;
        int num15 = 0;
        int num16 = num11;
        _ = 0;
        if (num16 < 0)
        {
            num16 = 0;
        }
        num11 = num16;
        if (num16 >= 1000000)
        {
            num12 = num16 / 1000000;
            num16 -= num12 * 1000000;
        }
        if (num16 >= 10000)
        {
            num13 = num16 / 10000;
            num16 -= num13 * 10000;
        }
        if (num16 >= 100)
        {
            num14 = num16 / 100;
            num16 -= num14 * 100;
        }
        if (num16 >= 1)
        {
            num15 = num16;
        }
        if (num12 > 0)
        {
            text2 = text2 + num12 + " " + Lang.inter[15].Value + " ";
        }
        if (num13 > 0)
        {
            text2 = text2 + num13 + " " + Lang.inter[16].Value + " ";
        }
        if (num14 > 0)
        {
            text2 = text2 + num14 + " " + Lang.inter[17].Value + " ";
        }
        if (num15 > 0)
        {
            text2 = text2 + num15 + " " + Lang.inter[18].Value + " ";
        }
        text = Language.GetTextValue("GameUI.BuyWithValue", text2);
        if (num11 == 0)
        {
            text = Language.GetTextValue("GameUI.Buy");
        }
        int num17 = (mouseTextColor * 2 + 255) / 3;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(num17, (int)((double)num17 / 1.1), num17 / 2, num17);
        float num18 = 0.9f;
        string text3 = text;
        int num19 = num2 + 18;
        int num20 = num + 156;
        bool flag = false;
        if (num11 > 0)
        {
            ItemSlot.DrawSavings(spriteBatch, num19, num20 - 70, horizontal: true);
        }
        if (num11 > 0 && mouseX > num19 && (float)mouseX < (float)num19 + FontAssets.MouseText.Value.MeasureString(text3).X && mouseY > num20 && (float)mouseY < (float)num20 + FontAssets.MouseText.Value.MeasureString(text3).Y)
        {
            flag = true;
            num18 = 1.1f;
            if (!npcChatFocus1)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus1 = true;
            player[myPlayer].releaseUseItem = false;
        }
        else
        {
            if (npcChatFocus1)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus1 = false;
        }
        Vector2 vector = FontAssets.MouseText.Value.MeasureString(text3);
        vector *= 0.5f;
        UILinkPointNavigator.SetPosition(2603, new Vector2(num19, num20) + vector);
        for (int i = 0; i < 5; i++)
        {
            int num21 = num19;
            int num22 = num20;
            Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Black;
            if (flag)
            {
                color2 = Microsoft.Xna.Framework.Color.Brown;
            }
            if (i == 0)
            {
                num21 -= 2;
            }
            if (i == 1)
            {
                num21 += 2;
            }
            if (i == 2)
            {
                num22 -= 2;
            }
            if (i == 3)
            {
                num22 += 2;
            }
            if (i == 4)
            {
                color2 = ((num11 != 0) ? color : new Microsoft.Xna.Framework.Color(100, 100, 100));
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text3, new Vector2((float)num21 + vector.X, (float)num22 + vector.Y), color2, 0f, vector, num18, SpriteEffects.None, 0f);
        }
        num18 = 0.9f;
        string textValue = Language.GetTextValue("GameUI.Cancel");
        num19 += 130;
        flag = false;
        if (mouseX > num19 && (float)mouseX < (float)num19 + FontAssets.MouseText.Value.MeasureString(textValue).X && mouseY > num20 && (float)mouseY < (float)num20 + FontAssets.MouseText.Value.MeasureString(textValue).Y)
        {
            flag = true;
            num18 = 1.1f;
            if (!npcChatFocus2)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus2 = true;
            player[myPlayer].releaseUseItem = false;
        }
        else
        {
            if (npcChatFocus2)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus2 = false;
        }
        vector = FontAssets.MouseText.Value.MeasureString(textValue);
        vector *= 0.5f;
        UILinkPointNavigator.SetPosition(2604, new Vector2(num19, num20) + vector);
        for (int j = 0; j < 5; j++)
        {
            int num23 = num19;
            int num24 = num20;
            Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.Black;
            if (flag)
            {
                color3 = Microsoft.Xna.Framework.Color.Brown;
            }
            if (j == 0)
            {
                num23 -= 2;
            }
            if (j == 1)
            {
                num23 += 2;
            }
            if (j == 2)
            {
                num24 -= 2;
            }
            if (j == 3)
            {
                num24 += 2;
            }
            if (j == 4)
            {
                color3 = color;
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, textValue, new Vector2((float)num23 + vector.X, (float)num24 + vector.Y), color3, 0f, vector, num18, SpriteEffects.None, 0f);
        }
        if (mouseLeft && mouseLeftRelease)
        {
            if (npcChatFocus1)
            {
                if (player[myPlayer].BuyItem(num11))
                {
                    BuyHairWindow();
                    return;
                }
            }
            else if (npcChatFocus2)
            {
                CancelHairWindow();
                return;
            }
        }
        if (!mouseLeft)
        {
            grabColorSlider = 0;
            blockMouse = false;
        }
        int num25 = 167;
        Vector3 vector2 = rgbToHsl(selColor);
        float num26 = vector2.X;
        float num27 = vector2.Y;
        float z = vector2.Z;
        float num28 = (float)(int)selColor.A / 255f;
        if (hBar == -1f || sBar == -1f || lBar == -1f || aBar == -1f)
        {
            hBar = num26;
            sBar = num27;
            lBar = z;
            aBar = (float)(int)selColor.A / 255f;
        }
        else
        {
            num26 = hBar;
            num27 = sBar;
            z = lBar;
            aBar = num28;
        }
        UILinkPointNavigator.SetPosition(2600, new Vector2(num4, num3) + TextureAssets.Hue.Value.Size() / 2f);
        spriteBatch.Draw(TextureAssets.Hue.Value, new Vector2(num4, num3), Microsoft.Xna.Framework.Color.White);
        if ((mouseX > num4 - 4 && mouseX < num4 + TextureAssets.Hue.Width() + 4 && mouseY > num3 - 4 && mouseY < num3 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 1)
        {
            spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num4, num3), OurFavoriteColor);
        }
        spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num4 + (float)(TextureAssets.Hue.Width() - 2) * hBar - (float)(TextureAssets.ColorSlider.Width() / 2), num3 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
        if (((mouseX > num4 - 4 && mouseX < num4 + TextureAssets.Hue.Width() + 4 && mouseY > num3 - 4 && mouseY < num3 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 1) && mouseLeft && !blockMouse)
        {
            grabColorSlider = 1;
            num26 = mouseX - num4;
            num26 /= (float)TextureAssets.Hue.Width();
            if (num26 < 0f)
            {
                num26 = 0f;
            }
            if (num26 > 1f)
            {
                num26 = 1f;
            }
            hBar = num26;
        }
        num3 += 26;
        UILinkPointNavigator.SetPosition(2601, new Vector2(num4, num3) + TextureAssets.ColorBar.Value.Size() / 2f);
        spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num4, num3), Microsoft.Xna.Framework.Color.White);
        for (int k = 0; k <= num25; k++)
        {
            float saturation = (float)k / (float)num25;
            Microsoft.Xna.Framework.Color color4 = hslToRgb(num26, saturation, z);
            spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num4 + k + 5, num3 + 4), color4);
        }
        if ((mouseX > num4 - 4 && mouseX < num4 + TextureAssets.Hue.Width() + 4 && mouseY > num3 - 4 && mouseY < num3 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 2)
        {
            spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num4, num3), OurFavoriteColor);
        }
        spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num4 + (float)(TextureAssets.Hue.Width() - 2) * sBar - (float)(TextureAssets.ColorSlider.Width() / 2), num3 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
        if (((mouseX > num4 - 4 && mouseX < num4 + TextureAssets.Hue.Width() + 4 && mouseY > num3 - 4 && mouseY < num3 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 2) && mouseLeft && !blockMouse)
        {
            grabColorSlider = 2;
            num27 = mouseX - num4;
            num27 /= (float)TextureAssets.Hue.Width();
            if (num27 < 0f)
            {
                num27 = 0f;
            }
            if (num27 > 1f)
            {
                num27 = 1f;
            }
            sBar = num27;
        }
        num3 += 26;
        UILinkPointNavigator.SetPosition(2602, new Vector2(num4, num3) + TextureAssets.ColorBar.Value.Size() / 2f);
        spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num4, num3), Microsoft.Xna.Framework.Color.White);
        float num29 = 0.15f;
        for (int l = 0; l <= num25; l++)
        {
            float luminosity = (float)l / (float)num25;
            Microsoft.Xna.Framework.Color color5 = hslToRgb(num26, num27, luminosity);
            spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num4 + l + 5, num3 + 4), color5);
        }
        if ((mouseX > num4 - 4 && mouseX < num4 + TextureAssets.Hue.Width() + 4 && mouseY > num3 - 4 && mouseY < num3 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 3)
        {
            spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num4, num3), OurFavoriteColor);
        }
        spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num4 + (float)(TextureAssets.Hue.Width() - 2) * ((lBar - num29) / (1f - num29)) - (float)(TextureAssets.ColorSlider.Width() / 2), num3 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
        if (((mouseX > num4 - 4 && mouseX < num4 + TextureAssets.Hue.Width() + 4 && mouseY > num3 - 4 && mouseY < num3 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 3) && mouseLeft && !blockMouse)
        {
            grabColorSlider = 3;
            z = mouseX - num4;
            z /= (float)TextureAssets.Hue.Width();
            if (z < 0f)
            {
                z = 0f;
            }
            if (z > 1f)
            {
                z = 1f;
            }
            z = z * (1f - num29) + num29;
            lBar = z;
        }
        selColor = hslToRgb(hBar, sBar, lBar);
        player[myPlayer].hairColor = selColor;
        int num30 = num5;
        int num31 = num6;
        _ = hairStart;
        int num32 = 0;
        int num33 = 0;
        for (int m = 0; m < 15; m++)
        {
            int num34 = Hairstyles.AvailableHairstyles[hairStart + m];
            UILinkPointNavigator.SetPosition(2605 + m, new Vector2(num30, num31) + TextureAssets.InventoryBack.Value.Size() * 0.75f);
            if (player[myPlayer].hair == num34)
            {
                spriteBatch.Draw(TextureAssets.InventoryBack14.Value, new Vector2(num30, num31), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.InventoryBack.Width(), TextureAssets.InventoryBack.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            else
            {
                spriteBatch.Draw(TextureAssets.InventoryBack8.Value, new Vector2(num30, num31), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.InventoryBack.Width(), TextureAssets.InventoryBack.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (mouseX > num30 && mouseX < num30 + TextureAssets.InventoryBack.Width() && mouseY > num31 && mouseY < num31 + TextureAssets.InventoryBack.Height())
            {
                Asset<Texture2D> val = Assets.Request<Texture2D>("Images/UI/PanelBorder", (AssetRequestMode)1);
                Utils.DrawSplicedPanel(spriteBatch, val.Value, num30, num31, TextureAssets.InventoryBack.Width(), TextureAssets.InventoryBack.Height(), val.Width() / 2 - 1, val.Width() / 2 - 1, val.Height() / 2 - 1, val.Height() / 2 - 1, OurFavoriteColor);
                if (mouseLeft && mouseLeftRelease)
                {
                    mouseLeftRelease = false;
                    player[myPlayer].hair = num34;
                    SoundEngine.PlaySound(12);
                }
            }
            LoadHair(num34);
            float x = num30 + TextureAssets.InventoryBack.Width() / 2 - TextureAssets.PlayerHair[num34].Width() / 2;
            float y = num31 + 4;
            spriteBatch.Draw(TextureAssets.Players[num32, 0].Value, new Vector2(x, y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.PlayerHair[num34].Width(), 56), player[myPlayer].skinColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.Players[num32, 1].Value, new Vector2(x, y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.PlayerHair[num34].Width(), 56), new Microsoft.Xna.Framework.Color(255, 255, 255, 255), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.Players[num32, 2].Value, new Vector2(x, y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.PlayerHair[num34].Width(), 56), player[myPlayer].eyeColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            Vector2 vector3 = player[myPlayer].GetHairDrawOffset(num34, hatHair: false) * player[myPlayer].Directions;
            spriteBatch.Draw(TextureAssets.PlayerHair[num34].Value, new Vector2(x, y) + vector3, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.PlayerHair[num34].Width(), 56), selColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            num33++;
            num30 += 56;
            if (num33 >= 5)
            {
                num33 = 0;
                num30 = num5;
                num31 += 56;
            }
        }
    }
 
    public static void OpenClothesWindow()
    {
        if (clothesWindow)
        {
            CancelClothesWindow();
            return;
        }
        hBar = -1f;
        lBar = -1f;
        sBar = -1f;
        playerInventory = false;
        npcChatText = "";
        clothesWindow = true;
        SoundEngine.PlaySound(10);
        selClothes = 0;
        oldClothesColor[0] = player[myPlayer].shirtColor;
        oldClothesColor[1] = player[myPlayer].underShirtColor;
        oldClothesColor[2] = player[myPlayer].pantsColor;
        oldClothesColor[3] = player[myPlayer].shoeColor;
        oldClothesColor[4] = player[myPlayer].eyeColor;
        oldClothesColor[5] = player[myPlayer].skinColor;
        if (dresserInterfaceDummy == null)
        {
            dresserInterfaceDummy = new Player();
        }
        oldClothesStyle = player[myPlayer].skinVariant;
    }
 
    public static void CancelClothesWindow(bool quiet = false)
    {
        if (clothesWindow)
        {
            clothesWindow = false;
            if (!quiet)
            {
                SoundEngine.PlaySound(11);
            }
            player[myPlayer].shirtColor = oldClothesColor[0];
            player[myPlayer].underShirtColor = oldClothesColor[1];
            player[myPlayer].pantsColor = oldClothesColor[2];
            player[myPlayer].shoeColor = oldClothesColor[3];
            player[myPlayer].eyeColor = oldClothesColor[4];
            player[myPlayer].skinColor = oldClothesColor[5];
            dresserInterfaceDummy.skinVariant = oldClothesStyle;
            dresserInterfaceDummy.Male = player[myPlayer].Male;
            player[myPlayer].skinVariant = dresserInterfaceDummy.skinVariant;
        }
    }
 
    public static void SaveClothesWindow()
    {
        SoundEngine.PlaySound(7);
        clothesWindow = false;
        NetMessage.SendData(4, -1, -1, null, myPlayer);
    }
 
    protected void DrawClothesWindow()
    {
        if (npcChatText != "" || playerInventory || player[myPlayer].chest != -1 || npcShop != 0 || player[myPlayer].talkNPC != -1 || InGuideCraftMenu)
        {
            CancelClothesWindow();
            return;
        }
        if (!LocalPlayer.IsInInteractionRangeToMultiTileHitbox(interactedDresserTopLeftX, interactedDresserTopLeftY) || !tile[interactedDresserTopLeftX, interactedDresserTopLeftY].active())
        {
            CancelClothesWindow();
            return;
        }
        int num = 477;
        int num2 = num / 2;
        num2 = 180;
        num = 511;
        num -= num / 2 - num2 - 26;
        int num3 = screenHeight / 2 + 60;
        int num4 = screenWidth / 2 - num / 2;
        int num5 = num3 + 32;
        int num6 = num4 + 22;
        num5 -= 16;
        int num7 = num4 + num - num2;
        int num8 = num3 + 18;
        if (selClothes == 0)
        {
            selColor = player[myPlayer].shirtColor;
        }
        if (selClothes == 1)
        {
            selColor = player[myPlayer].underShirtColor;
        }
        if (selClothes == 2)
        {
            selColor = player[myPlayer].pantsColor;
        }
        if (selClothes == 3)
        {
            selColor = player[myPlayer].shoeColor;
        }
        if (selClothes == 4)
        {
            selColor = player[myPlayer].eyeColor;
        }
        if (selClothes == 5)
        {
            selColor = player[myPlayer].skinColor;
        }
        Utils.DrawInvBG(spriteBatch, new Microsoft.Xna.Framework.Rectangle(num4, num3, num, 133));
        if (!PlayerInput.IgnoreMouseInterface && mouseX > num4 && mouseX < num4 + TextureAssets.ClothesStyleBack.Width() && mouseY > num3 && mouseY < num3 + TextureAssets.ClothesStyleBack.Height())
        {
            player[myPlayer].mouseInterface = true;
        }
        Vector2 vector = new Vector2(num4 + num / 2 - 16 - 28, num3 + 66 + dresserInterfaceDummy.height / 2 - 20);
        vector.Y += 18f;
        vector.X += 58f;
        Microsoft.Xna.Framework.Rectangle r = new Microsoft.Xna.Framework.Rectangle((int)vector.X - dresserInterfaceDummy.width / 2 - 15, (int)vector.Y - dresserInterfaceDummy.height - 33, dresserInterfaceDummy.width + 30, dresserInterfaceDummy.height + 66);
        bool flag = r.Contains(MouseScreen.ToPoint());
        int num9 = selClothes;
        int num10 = (mouseTextColor * 2 + 255) / 3;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(num10, (int)((double)num10 / 1.1), num10 / 2, num10);
        float num11 = 0.9f;
        string textValue = Language.GetTextValue("GameUI.Change");
        int num12 = num4 + num - num2 + 22;
        num12 = num4 + 22;
        int num13 = num3 + 94;
        bool flag2 = false;
        if (oldClothesColor[0] != player[myPlayer].shirtColor || oldClothesColor[1] != player[myPlayer].underShirtColor || oldClothesColor[2] != player[myPlayer].pantsColor || oldClothesColor[3] != player[myPlayer].shoeColor || oldClothesColor[4] != player[myPlayer].eyeColor || oldClothesColor[5] != player[myPlayer].skinColor || oldClothesStyle != player[myPlayer].skinVariant)
        {
            flag2 = true;
        }
        Vector2 vector2 = FontAssets.MouseText.Value.MeasureString(textValue);
        bool flag3 = false;
        UILinkPointNavigator.SetPosition(2803, new Vector2(num12, num13) + vector2 * num11 * 0.5f);
        if (flag2 && mouseX > num12 && (float)mouseX < (float)num12 + vector2.X && mouseY > num13 && (float)mouseY < (float)num13 + vector2.Y)
        {
            flag3 = true;
            num11 = 1.1f;
            if (!npcChatFocus1)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus1 = true;
            player[myPlayer].releaseUseItem = false;
        }
        else
        {
            if (npcChatFocus1)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus1 = false;
        }
        for (int i = 0; i < 5; i++)
        {
            int num14 = num12;
            int num15 = num13;
            Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Black;
            if (flag3)
            {
                color2 = Microsoft.Xna.Framework.Color.Brown;
            }
            if (i == 0)
            {
                num14 -= 2;
            }
            if (i == 1)
            {
                num14 += 2;
            }
            if (i == 2)
            {
                num15 -= 2;
            }
            if (i == 3)
            {
                num15 += 2;
            }
            if (i == 4)
            {
                color2 = (flag2 ? color : new Microsoft.Xna.Framework.Color(100, 100, 100));
            }
            Vector2 vector3 = FontAssets.MouseText.Value.MeasureString(textValue);
            vector3 *= 0.5f;
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, textValue, new Vector2((float)num14 + vector3.X, (float)num15 + vector3.Y), color2, 0f, vector3, num11, SpriteEffects.None, 0f);
        }
        num11 = 0.9f;
        string textValue2 = Language.GetTextValue("GameUI.Cancel");
        num12 += 130;
        bool flag4 = false;
        vector2 = FontAssets.MouseText.Value.MeasureString(textValue2);
        UILinkPointNavigator.SetPosition(2804, new Vector2(num12, num13) + vector2 * num11 * 0.5f);
        if (mouseX > num12 && (float)mouseX < (float)num12 + vector2.X && mouseY > num13 && (float)mouseY < (float)num13 + vector2.Y)
        {
            flag4 = true;
            num11 = 1.1f;
            if (!npcChatFocus2)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus2 = true;
            player[myPlayer].releaseUseItem = false;
        }
        else
        {
            if (npcChatFocus2)
            {
                SoundEngine.PlaySound(12);
            }
            npcChatFocus2 = false;
        }
        for (int j = 0; j < 5; j++)
        {
            int num16 = num12;
            int num17 = num13;
            Microsoft.Xna.Framework.Color color3 = Microsoft.Xna.Framework.Color.Black;
            if (flag4)
            {
                color3 = Microsoft.Xna.Framework.Color.Brown;
            }
            if (j == 0)
            {
                num16 -= 2;
            }
            if (j == 1)
            {
                num16 += 2;
            }
            if (j == 2)
            {
                num17 -= 2;
            }
            if (j == 3)
            {
                num17 += 2;
            }
            if (j == 4)
            {
                color3 = color;
            }
            Vector2 vector4 = FontAssets.MouseText.Value.MeasureString(textValue2);
            vector4 *= 0.5f;
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, textValue2, new Vector2((float)num16 + vector4.X, (float)num17 + vector4.Y), color3, 0f, vector4, num11, SpriteEffects.None, 0f);
        }
        if (mouseLeft && mouseLeftRelease)
        {
            if (npcChatFocus1)
            {
                SaveClothesWindow();
                return;
            }
            if (npcChatFocus2)
            {
                CancelClothesWindow();
                return;
            }
        }
        if (!mouseLeft)
        {
            grabColorSlider = 0;
            blockMouse = false;
        }
        int num18 = 167;
        Vector3 vector5 = rgbToHsl(selColor);
        float num19 = vector5.X;
        float num20 = vector5.Y;
        float z = vector5.Z;
        if (hBar == -1f || sBar == -1f || lBar == -1f)
        {
            hBar = num19;
            sBar = num20;
            lBar = z;
        }
        else
        {
            num19 = hBar;
            num20 = sBar;
            z = lBar;
        }
        spriteBatch.Draw(TextureAssets.Hue.Value, new Vector2(num6, num5), Microsoft.Xna.Framework.Color.White);
        if ((mouseX > num6 - 4 && mouseX < num6 + TextureAssets.Hue.Width() + 4 && mouseY > num5 - 4 && mouseY < num5 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 1)
        {
            spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num6, num5), OurFavoriteColor);
        }
        spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num6 + (float)(TextureAssets.Hue.Width() - 2) * hBar - (float)(TextureAssets.ColorSlider.Width() / 2), num5 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
        if (((mouseX > num6 - 4 && mouseX < num6 + TextureAssets.Hue.Width() + 4 && mouseY > num5 - 4 && mouseY < num5 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 1) && mouseLeft && !blockMouse)
        {
            grabColorSlider = 1;
            num19 = mouseX - num6;
            num19 /= (float)TextureAssets.Hue.Width();
            if (num19 < 0f)
            {
                num19 = 0f;
            }
            if (num19 > 1f)
            {
                num19 = 1f;
            }
            hBar = num19;
        }
        UILinkPointNavigator.SetPosition(2800, new Vector2(num6, num5) + TextureAssets.Hue.Value.Size() / 2f);
        num5 += 26;
        spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num6, num5), Microsoft.Xna.Framework.Color.White);
        for (int k = 0; k <= num18; k++)
        {
            float saturation = (float)k / (float)num18;
            Microsoft.Xna.Framework.Color color4 = hslToRgb(num19, saturation, z);
            spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num6 + k + 5, num5 + 4), color4);
        }
        if ((mouseX > num6 - 4 && mouseX < num6 + TextureAssets.Hue.Width() + 4 && mouseY > num5 - 4 && mouseY < num5 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 2)
        {
            spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num6, num5), OurFavoriteColor);
        }
        spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num6 + (float)(TextureAssets.Hue.Width() - 2) * sBar - (float)(TextureAssets.ColorSlider.Width() / 2), num5 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
        if (((mouseX > num6 - 4 && mouseX < num6 + TextureAssets.Hue.Width() + 4 && mouseY > num5 - 4 && mouseY < num5 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 2) && mouseLeft && !blockMouse)
        {
            grabColorSlider = 2;
            num20 = mouseX - num6;
            num20 /= (float)TextureAssets.Hue.Width();
            if (num20 < 0f)
            {
                num20 = 0f;
            }
            if (num20 > 1f)
            {
                num20 = 1f;
            }
            sBar = num20;
        }
        UILinkPointNavigator.SetPosition(2801, new Vector2(num6, num5) + TextureAssets.Hue.Value.Size() / 2f);
        num5 += 26;
        spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num6, num5), Microsoft.Xna.Framework.Color.White);
        float num21 = 0.15f;
        for (int l = 0; l <= num18; l++)
        {
            float luminosity = (float)l / (float)num18;
            Microsoft.Xna.Framework.Color color5 = hslToRgb(num19, num20, luminosity);
            spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num6 + l + 5, num5 + 4), color5);
        }
        if ((mouseX > num6 - 4 && mouseX < num6 + TextureAssets.Hue.Width() + 4 && mouseY > num5 - 4 && mouseY < num5 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 3)
        {
            spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num6, num5), OurFavoriteColor);
        }
        spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num6 + (float)(TextureAssets.Hue.Width() - 2) * ((lBar - num21) / (1f - num21)) - (float)(TextureAssets.ColorSlider.Width() / 2), num5 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
        if (((mouseX > num6 - 4 && mouseX < num6 + TextureAssets.Hue.Width() + 4 && mouseY > num5 - 4 && mouseY < num5 + TextureAssets.Hue.Height() + 4) || grabColorSlider == 3) && mouseLeft && !blockMouse)
        {
            grabColorSlider = 3;
            z = mouseX - num6;
            z /= (float)TextureAssets.Hue.Width();
            if (z < 0f)
            {
                z = 0f;
            }
            if (z > 1f)
            {
                z = 1f;
            }
            z = z * (1f - num21) + num21;
            lBar = z;
        }
        UILinkPointNavigator.SetPosition(2802, new Vector2(num6, num5) + TextureAssets.Hue.Value.Size() / 2f);
        selColor = hslToRgb(hBar, sBar, lBar);
        if (selClothes == 0)
        {
            player[myPlayer].shirtColor = selColor;
        }
        if (selClothes == 1)
        {
            player[myPlayer].underShirtColor = selColor;
        }
        if (selClothes == 2)
        {
            player[myPlayer].pantsColor = selColor;
        }
        if (selClothes == 3)
        {
            player[myPlayer].shoeColor = selColor;
        }
        if (selClothes == 4)
        {
            player[myPlayer].eyeColor = selColor;
        }
        if (selClothes == 5)
        {
            player[myPlayer].skinColor = selColor;
        }
        int num22 = num7;
        int num23 = num8;
        num23 -= 8;
        for (int m = 0; m < 6; m++)
        {
            if (num9 == m)
            {
                spriteBatch.Draw(TextureAssets.InventoryBack14.Value, new Vector2(num22, num23), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.InventoryBack.Width(), TextureAssets.InventoryBack.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            else
            {
                spriteBatch.Draw(TextureAssets.InventoryBack8.Value, new Vector2(num22, num23), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.InventoryBack.Width(), TextureAssets.InventoryBack.Height()), new Microsoft.Xna.Framework.Color(200, 200, 200, 200), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            if (mouseX > num22 && mouseX < num22 + TextureAssets.InventoryBack.Width() && mouseY > num23 && mouseY < num23 + TextureAssets.InventoryBack.Height() && mouseLeft && mouseLeftRelease)
            {
                mouseLeftRelease = false;
                selClothes = m;
                SoundEngine.PlaySound(12);
                hBar = -1f;
                lBar = -1f;
                sBar = -1f;
            }
            float x = num22 + TextureAssets.InventoryBack.Width() / 2 - TextureAssets.Clothes[m].Width() / 2;
            float y = num23 + TextureAssets.InventoryBack.Height() / 2 - TextureAssets.Clothes[m].Height() / 2;
            Microsoft.Xna.Framework.Color color6 = Microsoft.Xna.Framework.Color.White;
            if (m == 0)
            {
                color6 = player[myPlayer].shirtColor;
            }
            if (m == 1)
            {
                color6 = player[myPlayer].underShirtColor;
            }
            if (m == 2)
            {
                color6 = player[myPlayer].pantsColor;
            }
            if (m == 3)
            {
                color6 = player[myPlayer].shoeColor;
            }
            if (m == 4)
            {
                color6 = player[myPlayer].eyeColor;
            }
            if (m == 5)
            {
                color6 = player[myPlayer].skinColor;
            }
            spriteBatch.Draw(TextureAssets.Clothes[m].Value, new Vector2(x, y), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Clothes[m].Width(), TextureAssets.Clothes[m].Height()), color6, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            if (m == 4)
            {
                Texture2D value = Assets.Request<Texture2D>("Images/UI/CharCreation/ColorEyeBack", (AssetRequestMode)1).Value;
                spriteBatch.Draw(value, new Vector2(x, y), value.Frame(), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            UILinkPointNavigator.SetPosition(2806 + m, new Vector2(x, y) + TextureAssets.Clothes[m].Value.Size() * 0.75f);
            num22 += 56;
            if (m == 1)
            {
                num22 -= 112;
                num23 += 56;
            }
            if (m == 3)
            {
                num23 -= 56;
            }
            if (m == 4)
            {
                num23 += 56;
                num22 -= 56;
            }
        }
        dresserInterfaceDummy.skinVariant = player[myPlayer].skinVariant;
        dresserInterfaceDummy.eyeColor = player[myPlayer].eyeColor;
        dresserInterfaceDummy.hairColor = player[myPlayer].hairColor;
        dresserInterfaceDummy.hair = player[myPlayer].hair;
        dresserInterfaceDummy.skinColor = player[myPlayer].skinColor;
        dresserInterfaceDummy.shirtColor = player[myPlayer].shirtColor;
        dresserInterfaceDummy.underShirtColor = player[myPlayer].underShirtColor;
        dresserInterfaceDummy.shoeColor = player[myPlayer].shoeColor;
        dresserInterfaceDummy.pantsColor = player[myPlayer].pantsColor;
        dresserInterfaceDummy.Bottom = screenPosition + vector;
        dresserInterfaceDummy.direction = -1;
        dresserInterfaceDummy.gravDir = 1f;
        dresserInterfaceDummy.PlayerFrame();
        dresserInterfaceDummy.socialIgnoreLight = true;
        Microsoft.Xna.Framework.Color c = new Microsoft.Xna.Framework.Color(46, 106, 98) * 0.6f;
        if (flag)
        {
            c = new Microsoft.Xna.Framework.Color(46, 106, 98) * 2f * 0.6f;
            if (mouseLeft && mouseLeftRelease)
            {
                mouseLeftRelease = false;
                SoundEngine.PlaySound(12);
                CycleClothingStyle(player[myPlayer]);
            }
        }
        UILinkPointNavigator.SetPosition(2805, r.Center.ToVector2());
        Utils.DrawInvBG(spriteBatch, r, c);
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Immediate, null, null, null, null, null, UIScaleMatrix);
        PlayerRenderer.DrawPlayer(Camera, dresserInterfaceDummy, dresserInterfaceDummy.position, dresserInterfaceDummy.fullRotation, dresserInterfaceDummy.fullRotationOrigin);
    }
 
    private void DrawInterface_Tests()
    {
    }
 
    private void SetupDrawInterfaceLayers()
    {
        if (_needToSetupDrawInterfaceLayers)
        {
            _needToSetupDrawInterfaceLayers = false;
            _gameInterfaceLayers = new List<GameInterfaceLayer>();
            _gameInterfaceLayers.AddRange(new GameInterfaceLayer[43]
            {
                new LegacyGameInterfaceLayer("Vanilla: Interface Logic 1", delegate
                {
                    DrawInterface_0_InterfaceLogic1();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: MP Player Names", delegate
                {
                    DrawInterface_20_MultiplayerPlayerNames();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Emote Bubbles", delegate
                {
                    DrawInterface_1_1_DrawEmoteBubblesInWorld();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Entity Markers", delegate
                {
                    DrawInterface_1_2_DrawEntityMarkersInWorld();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Smart Cursor Targets", delegate
                {
                    DrawInterface_2_SmartCursorTargets();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Laser Ruler", delegate
                {
                    DrawInterface_3_LaserRuler();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Ruler", delegate
                {
                    DrawInterface_4_Ruler();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Gamepad Lock On", delegate
                {
                    DrawInterface_5_GamepadLockOn();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Tile Grid Option", delegate
                {
                    DrawInterface_6_TileGridOption();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Town NPC House Banners", delegate
                {
                    DrawInterface_7_TownNPCHouseBanners();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Hide UI Toggle", DrawInterface_8_CheckF11UIHideToggle, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Wire Selection", delegate
                {
                    DrawInterface_9_WireSelection();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Capture Manager Check", DrawInterface_10_CheckCaptureManager),
                new LegacyGameInterfaceLayer("Vanilla: Ingame Options", DrawInterface_11_IngameOptionsMenu, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Fancy UI", DrawInterface_12_IngameFancyUI, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Achievement Complete Popups", delegate
                {
                    DrawInterface_13_AchievementCompletePopups();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Entity Health Bars", delegate
                {
                    DrawInterface_14_EntityHealthBars();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Invasion Progress Bars", delegate
                {
                    DrawInterface_15_InvasionProgressBars();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Map / Minimap", delegate
                {
                    DrawInterface_16_MapOrMinimap();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Diagnose Net", delegate
                {
                    DrawInterface_17_DiagnoseNet();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Diagnose Video", delegate
                {
                    DrawInterface_18_DiagnoseVideo();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Sign Tile Bubble", delegate
                {
                    DrawInterface_19_SignTileBubble();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Hair Window", delegate
                {
                    DrawInterface_21_HairWindow();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Dresser Window", delegate
                {
                    DrawInterface_22_DresserWindow();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: NPC / Sign Dialog", delegate
                {
                    DrawInterface_23_NPCSignsDialog();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Interface Logic 2", delegate
                {
                    DrawInterface_24_InterfaceLogic2();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Resource Bars", delegate
                {
                    DrawInterface_25_ResourceBars();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Interface Logic 3", delegate
                {
                    DrawInterface_26_InterfaceLogic3();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Inventory", delegate
                {
                    DrawInterface_27_Inventory();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Info Accessories Bar", delegate
                {
                    DrawInterface_28_InfoAccs();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Settings Button", delegate
                {
                    DrawInterface_29_SettingsButton();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Hotbar", delegate
                {
                    DrawInterface_30_Hotbar();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Builder Accessories Bar", delegate
                {
                    DrawInterface_31_BuilderAccToggles();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Radial Hotbars", delegate
                {
                    DrawInterface_32_GamepadRadialHotbars();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Mouse Text", delegate
                {
                    DrawInterface_33_MouseText();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Player Chat", delegate
                {
                    DrawInterface_34_PlayerChat();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Death Text", delegate
                {
                    DrawInterface_35_YouDied();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Cursor", delegate
                {
                    DrawInterface_36_Cursor();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Debug Stuff", delegate
                {
                    DrawInterface_37_DebugStuff();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Mouse Item / NPC Head", delegate
                {
                    DrawInterface_38_MouseCarriedObject();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Mouse Over", delegate
                {
                    DrawInterface_39_MouseOver();
                    return true;
                }),
                new LegacyGameInterfaceLayer("Vanilla: Interact Item Icon", delegate
                {
                    DrawInterface_40_InteractItemIcon();
                    return true;
                }, InterfaceScaleType.UI),
                new LegacyGameInterfaceLayer("Vanilla: Interface Logic 4", delegate
                {
                    DrawInterface_41_InterfaceLogic4();
                    return true;
                }, InterfaceScaleType.UI)
            });
        }
    }
 
    protected void DrawInterface(GameTime gameTime)
    {
        _drawInterfaceGameTime = gameTime;
        if (_needToSetupDrawInterfaceLayers)
        {
            SetupDrawInterfaceLayers();
        }
        PlayerInput.SetZoom_UI();
        using (List<GameInterfaceLayer>.Enumerator enumerator = _gameInterfaceLayers.GetEnumerator())
        {
            while (enumerator.MoveNext() && enumerator.Current.Draw())
            {
            }
        }
        PlayerInput.SetZoom_World();
    }
 
    private static void DrawWallOfCopperShortswords()
    {
        UnifiedRandom r = new UnifiedRandom(5000);
        Texture2D value = TextureAssets.Cloud[28].Value;
        Vector2 vector = ScreenSize.ToVector2();
        spriteBatch.Begin();
        for (int i = 0; i < 20000; i++)
        {
            Vector2 vector2 = r.NextVector2Square(-0.1f, 1.1f);
            vector2.X -= 0.1f;
            vector2.X += GlobalTimeWrappedHourly % 10f / 10f * 1.2f;
            vector2.Y -= GlobalTimeWrappedHourly % 10f / 10f;
            if (vector2.Y < -0.2f)
            {
                vector2.Y += 1.4f;
            }
            if (vector2.X > 1.1f)
            {
                vector2.X -= 1.2f;
            }
            Vector2 position = vector2 * vector;
            spriteBatch.Draw(value, position, Microsoft.Xna.Framework.Color.White);
        }
        spriteBatch.End();
    }
 
    private static void DrawWallOfBoulders()
    {
        UnifiedRandom r = new UnifiedRandom(5000);
        instance.LoadProjectile(99);
        Texture2D value = TextureAssets.Projectile[99].Value;
        Vector2 vector = ScreenSize.ToVector2();
        spriteBatch.Begin();
        for (int i = 0; i < 20000; i++)
        {
            Vector2 vector2 = r.NextVector2Square(-0.1f, 1.1f);
            vector2.X *= 0.1f;
            vector2.X -= 0.1f;
            vector2.X += GlobalTimeWrappedHourly % 10f / 10f * 1.2f;
            vector2.Y -= GlobalTimeWrappedHourly % 10f / 10f;
            if (vector2.Y < -0.2f)
            {
                vector2.Y += 1.4f;
            }
            if (vector2.X > 1.1f)
            {
                vector2.X -= 1.2f;
            }
            Vector2 position = vector2 * vector;
            spriteBatch.Draw(value, position, Microsoft.Xna.Framework.Color.White);
        }
        spriteBatch.End();
    }
 
    private static void DrawInterface_41_InterfaceLogic4()
    {
        if (mouseRight)
        {
            npcChatRelease = false;
        }
        else
        {
            npcChatRelease = true;
        }
        _MouseOversCanClear = true;
        DrawPendingMouseText();
        cursorOverride = -1;
    }
 
    private static void DrawPendingMouseText()
    {
        DrawGamepadInstructions();
        if (instance._mouseTextCache.isValid)
        {
            instance.MouseTextInner(instance._mouseTextCache);
            DrawInterface_36_Cursor();
            instance._mouseTextCache.isValid = false;
            instance._mouseTextCache.noOverride = false;
        }
    }
 
    private void DrawInterface_40_InteractItemIcon()
    {
        if (HoveringOverAnNPC || LocalPlayer.mouseInterface)
        {
            return;
        }
        Item item = player[myPlayer].inventory[player[myPlayer].selectedItem];
        int num = item.type;
        if (player[myPlayer].UsingBiomeTorches)
        {
            switch (num)
            {
            case 8:
                num = player[myPlayer].BiomeTorchHoldStyle(num);
                break;
            case 966:
                num = player[myPlayer].BiomeCampfireHoldStyle(num);
                break;
            }
        }
        if (player[myPlayer].cursorItemIconID != 0)
        {
            num = player[myPlayer].cursorItemIconID;
        }
        bool flag = player[myPlayer].cursorItemIconEnabled && (player[myPlayer].inventory[player[myPlayer].selectedItem].type > 0 || player[myPlayer].cursorItemIconID != 0);
        ItemIconCacheVerification();
        bool flag2 = _itemIconCacheTime > 0 && mouseItem.type < 1;
        if (!(flag || flag2))
        {
            return;
        }
        int t = _itemIconCacheSelectedItemID;
        if (!flag)
        {
            Utils.Swap(ref t, ref player[myPlayer].cursorItemIconID);
        }
        Microsoft.Xna.Framework.Color currentColor = player[myPlayer].inventory[player[myPlayer].selectedItem].GetAlpha(Microsoft.Xna.Framework.Color.White);
        Microsoft.Xna.Framework.Color color = player[myPlayer].inventory[player[myPlayer].selectedItem].GetColor(Microsoft.Xna.Framework.Color.White);
        if (player[myPlayer].cursorItemIconID != 0)
        {
            currentColor = Microsoft.Xna.Framework.Color.White;
            color = default(Microsoft.Xna.Framework.Color);
        }
        if (player[myPlayer].cursorItemIconID == 269)
        {
            currentColor = player[myPlayer].shirtColor;
        }
        float num2 = 1f;
        num2 = cursorScale;
        ItemSlot.GetItemLight(ref currentColor, num);
        SpriteEffects effects = SpriteEffects.None;
        if (player[myPlayer].cursorItemIconReversed)
        {
            effects = SpriteEffects.FlipHorizontally;
        }
        if (num > 0)
        {
            int num3 = 10 + player[myPlayer].cursorItemIconPush;
            instance.LoadItem(num);
            spriteBatch.Draw(TextureAssets.Item[num].Value, new Vector2(mouseX + num3, mouseY + num3), Item.GetDrawHitbox(num, null), currentColor, 0f, default(Vector2), num2, effects, 0f);
            if (num == item.type && TryGetAmmo(item, out var ammoItem, out var ammoColor, out var ammoScale, out var ammoOffset))
            {
                float scale = num2 * ammoScale;
                int type = ammoItem.type;
                Microsoft.Xna.Framework.Color alpha = ammoItem.GetAlpha(ammoColor);
                instance.LoadItem(type);
                spriteBatch.Draw(TextureAssets.Item[type].Value, new Vector2(mouseX + 10, mouseY + 10) + ammoOffset, Item.GetDrawHitbox(type, null), alpha, 0f, default(Vector2), scale, effects, 0f);
            }
        }
        if (player[myPlayer].cursorItemIconText != "")
        {
            MouseText(player[myPlayer].cursorItemIconText, 0, 0);
        }
        if (player[myPlayer].cursorItemIconID == 0 && player[myPlayer].inventory[player[myPlayer].selectedItem].color != default(Microsoft.Xna.Framework.Color))
        {
            instance.LoadItem(player[myPlayer].inventory[player[myPlayer].selectedItem].type);
            spriteBatch.Draw(TextureAssets.Item[player[myPlayer].inventory[player[myPlayer].selectedItem].type].Value, new Vector2(mouseX + 10, mouseY + 10), Item.GetDrawHitbox(player[myPlayer].inventory[player[myPlayer].selectedItem].type, null), color, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        }
        if (!flag)
        {
            Utils.Swap(ref t, ref player[myPlayer].cursorItemIconID);
        }
    }
 
    private bool TryGetAmmo(Item sourceItem, out Item ammoItem, out Microsoft.Xna.Framework.Color ammoColor, out float ammoScale, out Vector2 ammoOffset)
    {
        ammoItem = null;
        ammoColor = Microsoft.Xna.Framework.Color.White;
        ammoScale = 0.8f;
        ammoOffset = Vector2.Zero;
        int type = sourceItem.type;
        if (type == 1071 || type == 1543 || type == 1072 || type == 1544)
        {
            int num = 22;
            int num2 = 22;
            if (type == 1072 || type == 1544)
            {
                num = 28;
                num2 = 28;
            }
            ammoOffset = new Vector2(num, num2);
            ammoItem = player[myPlayer].FindPaintOrCoating();
            return ammoItem != null;
        }
        FlexibleTileWand flexibleTileWand = sourceItem.GetFlexibleTileWand();
        if (flexibleTileWand != null && flexibleTileWand.TryGetPlacementOption(LocalPlayer, Player.FlexibleWandRandomSeed, Player.FlexibleWandCycleOffset, out var _, out ammoItem))
        {
            ammoOffset = new Vector2(28f, 28f);
            return true;
        }
        return false;
    }
 
    private void DrawInterface_39_MouseOver()
    {
        if (ignoreErrors)
        {
            try
            {
                DrawMouseOver();
                return;
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                return;
            }
        }
        DrawMouseOver();
    }
 
    private void DrawInterface_38_MouseCarriedObject()
    {
        if (mouseItem.type > 0 && mouseItem.stack > 0)
        {
            SetMouseNPC(-1, -1);
            player[myPlayer].cursorItemIconEnabled = false;
            player[myPlayer].cursorItemIconID = 0;
            mouseText = true;
            float num = inventoryScale;
            inventoryScale = cursorScale;
            ItemSlot.Draw(spriteBatch, ref mouseItem, 21, new Vector2(mouseX, mouseY));
            inventoryScale = num;
        }
        else
        {
            if (mouseNPCType <= -1)
            {
                return;
            }
            float num2 = 1f;
            num2 *= cursorScale;
            if (mouseNPCIndex >= 0)
            {
                NPC nPC = npc[mouseNPCIndex];
                if (!nPC.active || nPC.type != mouseNPCType)
                {
                    SetMouseNPC_ToHousingQuery();
                }
            }
            int type = mouseNPCType;
            int num3 = ((mouseNPCIndex >= 0) ? TownNPCProfiles.GetHeadIndexSafe(npc[mouseNPCIndex]) : NPC.TypeToDefaultHeadIndex(type));
            Texture2D value = TextureAssets.NpcHead[num3].Value;
            spriteBatch.Draw(value, new Vector2((float)mouseX + 26f * num2 - (float)value.Width * 0.5f * num2, (float)mouseY + 26f * num2 - (float)value.Height * 0.5f * num2), null, Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), num2, SpriteEffects.None, 0f);
            if (PlayerInput.IgnoreMouseInterface)
            {
                return;
            }
            player[myPlayer].mouseInterface = true;
            mouseText = false;
            if (mouseRight && mouseRightRelease)
            {
                SoundEngine.PlaySound(12);
                SetMouseNPC(-1, -1);
            }
            if (!mouseLeft || !mouseLeftRelease)
            {
                return;
            }
            if (mouseNPCType == 0)
            {
                PlayerInput.SetZoom_Unscaled();
                PlayerInput.SetZoom_MouseInWorld();
                int x = (int)(((float)mouseX + screenPosition.X) / 16f);
                int y = (int)(((float)mouseY + screenPosition.Y) / 16f);
                if (player[myPlayer].gravDir == -1f)
                {
                    y = (int)((screenPosition.Y + (float)screenHeight - (float)mouseY) / 16f);
                }
                PlayerInput.SetZoom_Unscaled();
                int n = -1;
                if (WorldGen.MoveTownNPC(x, y, n))
                {
                    NewText(Lang.inter[39].Value, byte.MaxValue, 240, 20);
                }
                return;
            }
            int num4 = mouseNPCIndex;
            if (num4 >= 0)
            {
                PlayerInput.SetZoom_Unscaled();
                PlayerInput.SetZoom_MouseInWorld();
                int x2 = (int)(((float)mouseX + screenPosition.X) / 16f);
                int y2 = (int)(((float)mouseY + screenPosition.Y) / 16f);
                PlayerInput.SetZoom_Unscaled();
                if (WorldGen.MoveTownNPC(x2, y2, num4))
                {
                    SetMouseNPC(-1, -1);
                    WorldGen.moveRoom(x2, y2, num4);
                    SoundEngine.PlaySound(12);
                }
            }
        }
    }
 
    private static void DrawInterface_37_DebugStuff()
    {
    }
 
    private static void DrawInterface_36_Cursor()
    {
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerStateForCursor, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
        if (cursorOverride != -1)
        {
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color((int)((float)(int)cursorColor.R * 0.2f), (int)((float)(int)cursorColor.G * 0.2f), (int)((float)(int)cursorColor.B * 0.2f), (int)((float)(int)cursorColor.A * 0.5f));
            Microsoft.Xna.Framework.Color white = cursorColor;
            bool flag = true;
            bool flag2 = true;
            float rotation = 0f;
            Vector2 vector = default(Vector2);
            float num = 1f;
            if (cursorOverride == 2)
            {
                flag = false;
                white = Microsoft.Xna.Framework.Color.White;
                num = 0.7f;
                vector = new Vector2(0.1f);
            }
            switch (cursorOverride)
            {
            case 2:
                flag = false;
                white = Microsoft.Xna.Framework.Color.White;
                num = 0.7f;
                vector = new Vector2(0.1f);
                break;
            case 3:
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:
                flag = false;
                white = Microsoft.Xna.Framework.Color.White;
                break;
            }
            if (flag)
            {
                spriteBatch.Draw(TextureAssets.Cursors[cursorOverride].Value, new Vector2(mouseX + 1, mouseY + 1), null, color, rotation, vector * TextureAssets.Cursors[cursorOverride].Value.Size(), cursorScale * 1.1f * num, SpriteEffects.None, 0f);
            }
            if (flag2)
            {
                spriteBatch.Draw(TextureAssets.Cursors[cursorOverride].Value, new Vector2(mouseX, mouseY), null, white, rotation, vector * TextureAssets.Cursors[cursorOverride].Value.Size(), cursorScale * num, SpriteEffects.None, 0f);
            }
        }
        else if (SmartCursorIsUsed)
        {
            DrawCursor(DrawThickCursor(smart: true), smart: true);
        }
        else
        {
            DrawCursor(DrawThickCursor());
        }
    }
 
    private static void DrawInterface_35_YouDied()
    {
        if (player[myPlayer].dead)
        {
            float num = -60f;
            string value = Lang.inter[38].Value;
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, value, new Vector2((float)(screenWidth / 2) - FontAssets.DeathText.Value.MeasureString(value).X / 2f, (float)(screenHeight / 2) + num), player[myPlayer].GetDeathAlpha(Microsoft.Xna.Framework.Color.Transparent), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            if (player[myPlayer].lostCoins > 0)
            {
                num += 50f;
                string textValue = Language.GetTextValue("Game.DroppedCoins", player[myPlayer].lostCoinString);
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, textValue, new Vector2((float)(screenWidth / 2) - FontAssets.MouseText.Value.MeasureString(textValue).X / 2f, (float)(screenHeight / 2) + num), player[myPlayer].GetDeathAlpha(Microsoft.Xna.Framework.Color.Transparent), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
            num += (float)((player[myPlayer].lostCoins > 0) ? 24 : 50);
            num += 20f;
            float num2 = 0.7f;
            string textValue2 = Language.GetTextValue("Game.RespawnInSuffix", ((float)(int)(1f + (float)player[myPlayer].respawnTimer / 60f)).ToString());
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, textValue2, new Vector2((float)(screenWidth / 2) - FontAssets.MouseText.Value.MeasureString(textValue2).X * num2 / 2f, (float)(screenHeight / 2) + num), player[myPlayer].GetDeathAlpha(Microsoft.Xna.Framework.Color.Transparent), 0f, default(Vector2), num2, SpriteEffects.None, 0f);
        }
    }
 
    private void DrawInterface_34_PlayerChat()
    {
        if (ignoreErrors)
        {
            try
            {
                DrawPlayerChat();
                return;
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                return;
            }
        }
        DrawPlayerChat();
    }
 
    private void DrawInterface_33_MouseText()
    {
        if (mouseItem.stack <= 0)
        {
            mouseItem.type = 0;
        }
        if (hoverItemName != null && hoverItemName != "" && mouseItem.type == 0)
        {
            player[myPlayer].cursorItemIconEnabled = false;
            if (SettingsEnabled_OpaqueBoxBehindTooltips)
            {
                MouseText(hoverItemName, rare, 0, mouseX + 6, mouseY + 6);
            }
            else
            {
                MouseText(hoverItemName, rare, 0);
            }
            mouseText = true;
        }
        if (LocalPlayer.rulerLine && LocalPlayer.builderAccStatus[0] == 0 && LocalPlayer.velocity.Length() <= 6f)
        {
            int num = Math.Abs(rulerLineDisplayValues.X) + 1;
            int num2 = Math.Abs(rulerLineDisplayValues.Y) + 1;
            if (num > 1 || num2 > 1)
            {
                Utils.DrawBorderString(spriteBatch, num + "x" + num2, MouseScreen + new Vector2(16f, 0f), new Microsoft.Xna.Framework.Color(0.24f, 0.8f, 0.9f, 1f), GameZoomTarget, 0f, 0.8f);
            }
        }
        DrawInterface_InstrumentMouseText();
    }
 
    private void DrawInterface_InstrumentMouseText()
    {
        Player localPlayer = LocalPlayer;
        if (_mouseTextCache.isValid || signHover > -1 || localPlayer.cursorItemIconID > 0 || localPlayer.selectedItem == 58 || (localPlayer.rulerLine && localPlayer.builderAccStatus[0] == 0) || localPlayer.mouseInterface)
        {
            instrumentMouseFixHack = 3;
            return;
        }
        if (instrumentMouseFixHack > 0)
        {
            instrumentMouseFixHack--;
            return;
        }
        int type = localPlayer.inventory[localPlayer.selectedItem].type;
        if (type == 4057 || type == 4372 || type == 4715 || type == 4673)
        {
            float musicDist = localPlayer.musicDist;
            string text = "GameUI.GuitarAm";
            if (type == 4673)
            {
                int num = 10;
                float num2 = 1f / (float)num;
                text = ((musicDist > num2 * 9f) ? "GameUI.DrumCymbol" : ((musicDist > num2 * 8f) ? "GameUI.DrumCymbol1" : ((musicDist > num2 * 7f) ? "GameUI.DrumHiHat" : ((musicDist > num2 * 6f) ? "GameUI.DrumClosedHiHat" : ((musicDist > num2 * 5f) ? "GameUI.DrumFloorTom" : ((musicDist > num2 * 4f) ? "GameUI.DrumTamaSnare" : ((musicDist > num2 * 3f) ? "GameUI.DrumTomHigh" : ((musicDist > num2 * 2f) ? "GameUI.DrumTomMid" : ((!(musicDist > num2 * 1f)) ? "GameUI.DrumKick" : "GameUI.DrumTomLow")))))))));
            }
            else
            {
                int num3 = 6;
                float num4 = 1f / (float)num3;
                text = ((musicDist > num4 * 5f) ? "GameUI.GuitarEm" : ((musicDist > num4 * 4f) ? "GameUI.GuitarD" : ((musicDist > num4 * 3f) ? "GameUI.GuitarC" : ((musicDist > num4 * 2f) ? "GameUI.GuitarBm" : ((!(musicDist > num4 * 1f)) ? "GameUI.GuitarG" : "GameUI.GuitarAm")))));
            }
            MouseText(Language.GetTextValue(Language.GetTextValue(text)), 0, 0);
        }
    }
 
    private static void DrawInterface_32_GamepadRadialHotbars()
    {
        ItemSlot.DrawRadialCircular(spriteBatch, new Vector2(screenWidth, screenHeight) / 2f, LocalPlayer.CircularRadial, LocalPlayer.inventory);
        ItemSlot.DrawRadialQuicks(spriteBatch, new Vector2(screenWidth, screenHeight) / 2f);
    }
 
    private void DrawInterface_31_BuilderAccToggles()
    {
        DrawBuilderAccToggles(new Vector2(10f, 77f));
    }
 
    public static void DrawInterface_29_SettingsButton()
    {
        _settingsButtonIsPushedToSide = false;
        if (playerInventory || ingameOptionsWindow || player[myPlayer].ghost || player[myPlayer].dead)
        {
            string value = Lang.inter[62].Value;
            string textSizeMatcher = "Settings";
            int num = screenWidth - 110;
            int num2 = screenHeight - 20;
            int num3 = 620;
            int num4 = 870;
            int amountOfExtraAccessorySlotsToShow = player[myPlayer].GetAmountOfExtraAccessorySlotsToShow();
            if (amountOfExtraAccessorySlotsToShow > 1)
            {
                int num5 = (int)(56f * inventoryScale * (float)(amountOfExtraAccessorySlotsToShow - 1));
                num3 += num5;
                num4 += num5;
            }
            if (amountOfExtraAccessorySlotsToShow >= 1 && (screenHeight < num3 || (screenHeight < num4 && mapStyle == 1)))
            {
                num -= 140;
                num2 -= PlayerInput.SettingsForUI.PushEquipmentAreaUp.ToInt() * 30;
                _settingsButtonIsPushedToSide = true;
            }
            Action clickAction = IngameOptions.Open;
            if (ingameOptionsWindow)
            {
                clickAction = IngameOptions.Close;
            }
            DrawSettingButton(ref mouseExit, ref exitScale, num, num2, value, textSizeMatcher, clickAction);
        }
    }
 
    public static void DrawSettingButton(ref bool mouseOver, ref float scale, int posX, int posY, string text, string textSizeMatcher, Action clickAction)
    {
        Vector2 vector = FontAssets.MouseText.Value.MeasureString(textSizeMatcher);
        Vector2 vector2 = FontAssets.MouseText.Value.MeasureString(text);
        Vector2 vector3 = FontAssets.DeathText.Value.MeasureString(text);
        float num = vector.X / vector2.X;
        if (mouseOver)
        {
            if ((double)scale < 0.96)
            {
                scale += 0.02f;
            }
        }
        else if ((double)scale > 0.8)
        {
            scale -= 0.02f;
        }
        UILinkPointNavigator.SetPosition(308, new Vector2(posX, posY));
        for (int i = 0; i < 5; i++)
        {
            int num2 = 0;
            int num3 = 0;
            Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Black;
            if (i == 0)
            {
                num2 = -2;
            }
            if (i == 1)
            {
                num2 = 2;
            }
            if (i == 2)
            {
                num3 = -2;
            }
            if (i == 3)
            {
                num3 = 2;
            }
            if (i == 4)
            {
                color = Microsoft.Xna.Framework.Color.White;
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, text, new Vector2(posX + num2, posY + num3), color, 0f, new Vector2(vector3.X / 2f, vector3.Y / 2f), (scale - 0.2f) * num, SpriteEffects.None, 0f);
        }
        if ((float)mouseX > (float)posX - vector3.X / 2f && (float)mouseX < (float)posX + vector3.X / 2f && (float)mouseY > (float)posY - vector3.Y / 2f && (float)mouseY < (float)posY + vector3.Y / 2f - 10f && !LocalPlayer.mouseInterface)
        {
            if (!PlayerInput.IgnoreMouseInterface)
            {
                if (!mouseOver)
                {
                    SoundEngine.PlaySound(12);
                }
                mouseOver = true;
                player[myPlayer].mouseInterface = true;
                if (mouseLeftRelease && mouseLeft)
                {
                    mouseOver = false;
                    scale = 0.8f;
                    clickAction();
                }
            }
        }
        else
        {
            mouseOver = false;
        }
    }
 
    private void DrawInterface_28_InfoAccs()
    {
        float num = inventoryScale;
        inventoryScale = 0.6f;
        DrawInfoAccs();
        inventoryScale = num;
    }
 
    private void HackForGamepadInputHell()
    {
        if (PlayerInput.SettingsForUI.ShowGamepadHints)
        {
            PlayerInput.ComposeInstructionsForGamepad();
            PlayerInput.AllowExecutionOfGamepadInstructions = false;
        }
    }
 
    private void DrawInterface_27_Inventory()
    {
        HackForGamepadInputHell();
        if (playerInventory)
        {
            if (player[myPlayer].chest != -1)
            {
                CreativeMenu.CloseMenu();
            }
            if (ignoreErrors)
            {
                try
                {
                    DrawInventory();
                    return;
                }
                catch (Exception e)
                {
                    TimeLogger.DrawException(e);
                    return;
                }
            }
            DrawInventory();
        }
        else
        {
            CreativeMenu.CloseMenu();
            recFastScroll = true;
            SetMouseNPC(-1, -1);
            EquipPage = 0;
        }
    }
 
    private static void DrawInterface_26_InterfaceLogic3()
    {
        bool flag = playerInventory;
        if (player[myPlayer].dead)
        {
            playerInventory = false;
        }
        if (!playerInventory)
        {
            player[myPlayer].chest = -1;
            InGuideCraftMenu = false;
            InReforgeMenu = false;
            if (flag)
            {
                Recipe.FindRecipes();
            }
        }
        hoverItemName = "";
    }
 
    private void DrawInterface_25_ResourceBars()
    {
        GUIBarsDraw();
    }
 
    private static void DrawInterface_24_InterfaceLogic2()
    {
        invAlpha += invDir * 0.2f;
        if (invAlpha > 240f)
        {
            invAlpha = 240f;
            invDir = -1f;
        }
        if (invAlpha < 180f)
        {
            invAlpha = 180f;
            invDir = 1f;
        }
        inventoryBack = new Microsoft.Xna.Framework.Color((byte)invAlpha, (byte)invAlpha, (byte)invAlpha, (byte)invAlpha);
        mouseText = false;
        rare = 0;
    }
 
    private void DrawInterface_23_NPCSignsDialog()
    {
        GUIChatDraw();
    }
 
    private void DrawInterface_22_DresserWindow()
    {
        if (clothesWindow)
        {
            DrawClothesWindow();
        }
    }
 
    private void DrawInterface_21_HairWindow()
    {
        if (hairWindow)
        {
            DrawHairWindow();
        }
    }
 
    private static void DrawInterface_20_MultiplayerPlayerNames()
    {
        ActiveClosePlayersTeamOverlay.Draw();
    }
 
    private static void DrawInterface_19_SignTileBubble()
    {
        if (signBubble)
        {
            int num = (int)((float)signX - screenPosition.X);
            int num2 = (int)((float)signY - screenPosition.Y);
            if (player[myPlayer].gravDir == -1f)
            {
                num2 = screenHeight - (int)((float)signY - screenPosition.Y) - 32;
            }
            SpriteEffects effects = SpriteEffects.None;
            if ((float)signX > player[myPlayer].position.X + (float)player[myPlayer].width)
            {
                effects = SpriteEffects.FlipHorizontally;
                num += -8 - TextureAssets.Chat2.Width();
            }
            else
            {
                num += 8;
            }
            num2 -= 22;
            spriteBatch.Draw(TextureAssets.Chat2.Value, new Vector2(num, num2), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Chat2.Width(), TextureAssets.Chat2.Height()), new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, default(Vector2), 1f, effects, 0f);
            signBubble = false;
        }
    }
 
    private static void DrawInterface_18_DiagnoseVideo()
    {
        if (!drawDiag)
        {
            return;
        }
        if (PlayerInput.UsingGamepad)
        {
            for (int i = 0; i < 2; i++)
            {
                string text = "";
                int num = 20;
                int num2 = 160;
                num2 += i * 16;
                if (i == 0)
                {
                    text = "Gamepad Left Thumbstick  : " + string.Format("{0,-10} ,   {1,-10}", PlayerInput.GamepadThumbstickLeft.X.ToString("P2"), PlayerInput.GamepadThumbstickLeft.Y.ToString("P2"));
                }
                if (i == 1)
                {
                    text = "Gamepad Right Thumbstick: " + string.Format("{0,-10} ,   {1,-10}", PlayerInput.GamepadThumbstickRight.X.ToString("P2"), PlayerInput.GamepadThumbstickRight.Y.ToString("P2"));
                }
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(num, num2), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
        }
        for (int j = 0; j < 7; j++)
        {
            string text2 = "";
            int num3 = 20;
            int num4 = 220;
            num4 += j * 16;
            if (j == 0)
            {
                text2 = "Solid Tiles:";
            }
            if (j == 1)
            {
                text2 = "Misc. Tiles:";
            }
            if (j == 2)
            {
                text2 = "Walls Tiles:";
            }
            if (j == 3)
            {
                text2 = "Background Tiles:";
            }
            if (j == 4)
            {
                text2 = "Water Tiles:";
            }
            if (j == 5)
            {
                text2 = "Black Tiles:";
            }
            if (j == 6)
            {
                text2 = "Total Render:";
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text2, new Vector2(num3, num4), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        for (int k = 0; k < 7; k++)
        {
            string text3 = "";
            int num5 = 180;
            int num6 = 220;
            num6 += k * 16;
            float num7 = ((k != 6) ? TimeLogger.GetDrawTime(k) : TimeLogger.GetDrawTotal());
            text3 = $"{num7:F2}ms";
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text3, new Vector2(num5, num6), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        for (int l = 0; l < 6; l++)
        {
            string text4 = "";
            int num8 = 20;
            int num9 = 346;
            num9 += l * 16;
            if (l == 0)
            {
                text4 = "Lighting Init:";
            }
            if (l == 1)
            {
                text4 = "Lighting Phase #1:";
            }
            if (l == 2)
            {
                text4 = "Lighting Phase #2:";
            }
            if (l == 3)
            {
                text4 = "Lighting Phase #3";
            }
            if (l == 4)
            {
                text4 = "Lighting Phase #4";
            }
            if (l == 5)
            {
                text4 = "Total Lighting:";
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text4, new Vector2(num8, num9), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        for (int m = 0; m < 6; m++)
        {
            string text5 = "";
            int num10 = 180;
            int num11 = 346;
            num11 += m * 16;
            float num12 = ((m != 5) ? TimeLogger.GetLightingTime(m) : TimeLogger.GetLightingTotal());
            text5 = $"{num12:F2}ms";
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text5, new Vector2(num10, num11), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        int num13 = 5;
        for (int n = 0; n < num13; n++)
        {
            string text6 = "";
            int num14 = 20;
            int num15 = 456;
            num15 += n * 16;
            text6 = "Render #" + n + ":";
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text6, new Vector2(num14, num15), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        for (int num16 = 0; num16 < num13; num16++)
        {
            string text7 = "";
            int num17 = 180;
            int num18 = 456;
            num18 += num16 * 16;
            text7 = $"{TimeLogger.GetRenderTime(num16):F2}ms";
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text7, new Vector2(num17, num18), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        for (int num19 = 0; num19 < num13; num19++)
        {
            string text8 = "";
            int num20 = 230;
            int num21 = 456;
            num21 += num19 * 16;
            num20 += 10;
            text8 = $"{TimeLogger.GetRenderMax(num19):F2}ms";
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text8, new Vector2(num20, num21), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        string text9 = "";
        int num22 = 20;
        int num23 = 456 + 16 * num13 + 16;
        text9 = "Update:";
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text9, new Vector2(num22, num23), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        text9 = "";
        num22 = 180;
        text9 = $"{upTimer:F2}ms";
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text9, new Vector2(num22, num23), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        text9 = "";
        num22 = 240;
        text9 = $"{upTimerMax:F2}ms";
        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text9, new Vector2(num22, num23), Microsoft.Xna.Framework.Color.White, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
    }
 
    private static void DrawInterface_17_DiagnoseNet()
    {
        if (shouldDrawNetDiagnosticsUI)
        {
            ActiveNetDiagnosticsUI.Draw(spriteBatch);
        }
    }
 
    private void DrawInterface_16_MapOrMinimap()
    {
        mH = 0;
        if (!mapEnabled)
        {
            return;
        }
        if (!mapFullscreen && mapStyle == 1)
        {
            mH = 256;
            try
            {
                DrawMap(new GameTime());
            }
            catch (Exception e)
            {
                if (!ignoreErrors)
                {
                    throw;
                }
                TimeLogger.DrawException(e);
            }
        }
        PlayerInput.SetZoom_UI();
        if (mH + RecommendedEquipmentAreaPushUp > screenHeight)
        {
            mH = screenHeight - RecommendedEquipmentAreaPushUp;
        }
    }
 
    private static void DrawInterface_15_InvasionProgressBars()
    {
        DrawInvasionProgress();
        if (HealthBarDrawSettings != 0)
        {
            BigBossProgressBar.Draw(spriteBatch);
        }
    }
 
    private void DrawInterface_14_EntityHealthBars()
    {
        if (HealthBarDrawSettings == 0)
        {
            return;
        }
        int num = -1;
        if (PlayerInput.UsingGamepad)
        {
            Player localPlayer = LocalPlayer;
            for (int i = 0; i < 200; i++)
            {
                NPC nPC = npc[i];
                if ((nPC.life == nPC.lifeMax || nPC.dontTakeDamage) && !nPC.dontTakeDamage && nPC.nameOver > 0f && (num == -1 || nPC.Distance(localPlayer.Center) < npc[num].Distance(localPlayer.Center)))
                {
                    num = i;
                }
            }
        }
        bool flag = false;
        for (int num2 = 199; num2 >= 0; num2--)
        {
            if (npc[num2].active && npc[num2].type > 0 && npc[num2].shimmerTransparency == 0f)
            {
                npc[num2].position += npc[num2].netOffset;
                if (npc[num2].life != npc[num2].lifeMax && !npc[num2].dontTakeDamage)
                {
                    float scale = 1f;
                    int type = npc[num2].type;
                    if (type == 4)
                    {
                        scale = 1.5f;
                    }
                    if (type == 35)
                    {
                        scale = 1.5f;
                    }
                    if (type == 36)
                    {
                        scale = 1.5f;
                    }
                    if (type == 50)
                    {
                        scale = 1.5f;
                    }
                    if (type == 113)
                    {
                        scale = 1.5f;
                    }
                    if (type == 114)
                    {
                        scale = 1.5f;
                    }
                    if (type == 125)
                    {
                        scale = 1.5f;
                    }
                    if (type == 126)
                    {
                        scale = 1.5f;
                    }
                    if (type == 127)
                    {
                        scale = 1.5f;
                    }
                    if (type == 128)
                    {
                        scale = 1.5f;
                    }
                    if (type == 129)
                    {
                        scale = 1.5f;
                    }
                    if (type == 130)
                    {
                        scale = 1.5f;
                    }
                    if (type == 131)
                    {
                        scale = 1.5f;
                    }
                    if (type == 222)
                    {
                        scale = 1.5f;
                    }
                    if (type >= 245 && type <= 249)
                    {
                        scale = 1.5f;
                    }
                    if (type == 262)
                    {
                        scale = 1.5f;
                    }
                    if (type == 266)
                    {
                        scale = 1.5f;
                    }
                    if (type == 564 || type == 565 || type == 551 || type == 576 || type == 577)
                    {
                        scale = 1.5f;
                    }
                    if (type == 87)
                    {
                        scale = 1.5f;
                    }
                    if (type == 510 || type == 454 || type == 621)
                    {
                        scale = 1.5f;
                    }
                    if (type == 439 || type == 370)
                    {
                        scale = 1.5f;
                    }
                    float num3 = 10f;
                    if (HealthBarDrawSettings == 2)
                    {
                        num3 -= 34f;
                    }
                    if ((!expertMode || type != 266) && ((type != 439 && type != 440) || npc[num2].ai[0] != 5f))
                    {
                        if (type >= 134 && type <= 136)
                        {
                            scale = 1.5f;
                            if (!flag)
                            {
                                flag = true;
                                Vector2 vector = default(Vector2);
                                float num4 = 999999f;
                                for (int j = 0; j < 200; j++)
                                {
                                    if (npc[j].active && npc[j].type >= 134 && npc[j].type <= 136)
                                    {
                                        Vector2 vector2 = player[myPlayer].Center - npc[j].Center;
                                        if (vector2.Length() < num4 && Collision.CanHit(player[myPlayer].Center, 1, 1, npc[j].Center, 1, 1))
                                        {
                                            num4 = vector2.Length();
                                            vector = npc[j].position;
                                        }
                                    }
                                }
                                if (num4 < (float)screenWidth)
                                {
                                    if (destroyerHB.X < 100f && destroyerHB.Y < 100f)
                                    {
                                        destroyerHB = vector;
                                    }
                                    else
                                    {
                                        destroyerHB = (destroyerHB * 49f + vector) / 50f;
                                    }
                                    vector = destroyerHB;
                                    int num5 = num2;
                                    if (type != 134 && npc[num2].realLife != -1)
                                    {
                                        num5 = npc[num2].realLife;
                                    }
                                    float num6 = Lighting.Brightness((int)((npc[num2].position.X + (float)(npc[num2].width / 2)) / 16f), (int)((npc[num2].position.Y + (float)(npc[num2].height / 2) + npc[num2].gfxOffY) / 16f));
                                    num6 = (num6 + 1f) / 2f;
                                    DrawHealthBar(vector.X + (float)(npc[num2].width / 2), vector.Y + (float)(npc[num2].height / 2), npc[num5].life, npc[num5].lifeMax, num6, scale);
                                }
                                else
                                {
                                    destroyerHB = new Vector2(0f, 0f);
                                }
                            }
                        }
                        else
                        {
                            switch (type)
                            {
                            case 7:
                                DrawInterface_Healthbar_Worm(npc[num2], 9, scale);
                                break;
                            case 95:
                                DrawInterface_Healthbar_Worm(npc[num2], 97, scale);
                                break;
                            case 10:
                                DrawInterface_Healthbar_Worm(npc[num2], 12, scale);
                                break;
                            case 87:
                                DrawInterface_Healthbar_Worm(npc[num2], 92, scale);
                                break;
                            default:
                                switch (type)
                                {
                                case 412:
                                    DrawInterface_Healthbar_Worm(npc[num2], 414, scale);
                                    break;
                                case 39:
                                    DrawInterface_Healthbar_Worm(npc[num2], 41, scale);
                                    break;
                                case 98:
                                    DrawInterface_Healthbar_Worm(npc[num2], 100, scale);
                                    break;
                                case 454:
                                    DrawInterface_Healthbar_Worm(npc[num2], 459, scale);
                                    break;
                                default:
                                    switch (type)
                                    {
                                    case 510:
                                        DrawInterface_Healthbar_Worm(npc[num2], 512, scale);
                                        break;
                                    case 621:
                                        DrawInterface_Healthbar_Worm(npc[num2], 623, scale);
                                        break;
                                    case 513:
                                        DrawInterface_Healthbar_Worm(npc[num2], 515, scale);
                                        break;
                                    case 117:
                                        DrawInterface_Healthbar_Worm(npc[num2], 119, scale);
                                        break;
                                    default:
                                        if (HealthBarDrawSettings == 1)
                                        {
                                            num3 += NPCAddHeight(npc[num2]);
                                            DrawHealthBar(npc[num2].position.X + (float)(npc[num2].width / 2), npc[num2].position.Y + (float)npc[num2].height + num3 + npc[num2].gfxOffY, npc[num2].life, npc[num2].lifeMax, Lighting.Brightness((int)((npc[num2].position.X + (float)(npc[num2].width / 2)) / 16f), (int)((npc[num2].position.Y + (float)(npc[num2].height / 2) + npc[num2].gfxOffY) / 16f)), scale);
                                        }
                                        else if (HealthBarDrawSettings == 2)
                                        {
                                            num3 -= NPCAddHeight(npc[num2]) / 2f;
                                            DrawHealthBar(npc[num2].position.X + (float)(npc[num2].width / 2), npc[num2].position.Y + num3 + npc[num2].gfxOffY, npc[num2].life, npc[num2].lifeMax, Lighting.Brightness((int)((npc[num2].position.X + (float)(npc[num2].width / 2)) / 16f), (int)((npc[num2].position.Y + (float)(npc[num2].height / 2) + npc[num2].gfxOffY) / 16f)), scale);
                                        }
                                        break;
                                    case 118:
                                    case 119:
                                    case 511:
                                    case 512:
                                    case 514:
                                    case 515:
                                    case 622:
                                    case 623:
                                        break;
                                    }
                                    break;
                                case 40:
                                case 41:
                                case 99:
                                case 100:
                                case 413:
                                case 414:
                                case 455:
                                case 456:
                                case 457:
                                case 458:
                                case 459:
                                    break;
                                }
                                break;
                            case 8:
                            case 9:
                            case 11:
                            case 12:
                            case 88:
                            case 89:
                            case 90:
                            case 91:
                            case 92:
                            case 96:
                            case 97:
                                break;
                            }
                        }
                    }
                }
                else if (!npc[num2].dontTakeDamage && npc[num2].nameOver > 0f && PlayerInput.UsingGamepad && num2 == num)
                {
                    Vector2 stringSize = ChatManager.GetStringSize(FontAssets.MouseText.Value, npc[num2].GivenOrTypeName, Vector2.One);
                    Vector2 vector3 = npc[num2].Bottom - screenPosition + new Vector2(0f, 10f);
                    if (NPC.GetNPCLocation(num2, seekHead: true, averageDirection: true, out var _, out var pos))
                    {
                        vector3 = pos - screenPosition + new Vector2(0f, 10 + npc[num2].height / 2);
                        if (player[myPlayer].gravDir == -1f)
                        {
                            vector3 = ReverseGravitySupport(vector3, -npc[num2].height - 20);
                        }
                        Vector2 origin = stringSize * new Vector2(0.5f, 0f);
                        ChatManager.DrawColorCodedStringShadow(spriteBatch, FontAssets.MouseText.Value, npc[num2].GivenOrTypeName, vector3, Microsoft.Xna.Framework.Color.Black * npc[num2].nameOver * 0.5f, 0f, origin, Vector2.One);
                        ChatManager.DrawColorCodedString(spriteBatch, FontAssets.MouseText.Value, npc[num2].GivenOrTypeName, vector3, Microsoft.Xna.Framework.Color.White * npc[num2].nameOver, 0f, origin, Vector2.One);
                    }
                }
                if (npc[num2].type == 548 && !npc[num2].dontTakeDamageFromHostiles && DD2Event.TimeLeftBetweenWaves > 0 && !hideUI)
                {
                    Vector2 position = npc[num2].Bottom - screenPosition + new Vector2(0f, -100f);
                    int num7 = DD2Event.TimeLeftBetweenWaves / 60;
                    string text = $"{num7}";
                    DynamicSpriteFont value = FontAssets.MouseText.Value;
                    float num8 = 1f;
                    Vector2 origin2 = value.MeasureString(text) * num8 * new Vector2(0.5f, 0.5f);
                    ChatManager.DrawColorCodedStringWithShadow(spriteBatch, value, text, position, Microsoft.Xna.Framework.Color.White, 0f, origin2, Vector2.One * num8);
                }
                npc[num2].position -= npc[num2].netOffset;
            }
        }
        for (int k = 0; k < 255; k++)
        {
            if (k != myPlayer && player[k].active && !player[k].ghost && !player[k].dead && !player[k].invis && player[k].statLife != player[k].statLifeMax2)
            {
                if (HealthBarDrawSettings == 1)
                {
                    int num9 = 10;
                    DrawHealthBar(player[k].position.X + (float)(player[k].width / 2), player[k].position.Y + (float)player[k].height + (float)num9 + player[k].gfxOffY, player[k].statLife, player[k].statLifeMax2, player[k].stealth * Lighting.Brightness((int)((player[k].position.X + (float)(player[k].width / 2)) / 16f), (int)((player[k].position.Y + (float)(player[k].height / 2) + player[k].gfxOffY) / 16f)));
                }
                else if (HealthBarDrawSettings == 2)
                {
                    int num10 = -20;
                    DrawHealthBar(player[k].position.X + (float)(player[k].width / 2), player[k].position.Y + (float)num10 + player[k].gfxOffY, player[k].statLife, player[k].statLifeMax2, player[k].stealth * Lighting.Brightness((int)((player[k].position.X + (float)(player[k].width / 2)) / 16f), (int)((player[k].position.Y + (float)(player[k].height / 2) + player[k].gfxOffY) / 16f)));
                }
            }
        }
    }
 
    private void DrawInterface_Healthbar_Worm(NPC head, int tailID, float scale)
    {
        NPC nPC = head;
        for (int i = head.whoAmI + 1; i < 200; i++)
        {
            if (npc[i].active && npc[i].type == tailID)
            {
                nPC = npc[i];
                break;
            }
        }
        Vector2 vector = (head.position + nPC.position) / 2f;
        DrawHealthBar(vector.X + (float)(head.width / 2), vector.Y + (float)(head.height / 2), head.life, head.lifeMax, Lighting.Brightness((int)((head.position.X + (float)(head.width / 2)) / 16f), (int)((head.position.Y + (float)(head.height / 2) + head.gfxOffY) / 16f)), scale);
    }
 
    private static void DrawInterface_13_AchievementCompletePopups()
    {
        InGameNotificationsTracker.DrawInGame(spriteBatch);
    }
 
    private static bool DrawInterface_12_IngameFancyUI()
    {
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerStateForCursor, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
        InGameUI.Draw(spriteBatch, _drawInterfaceGameTime);
        bool result = true;
        if (inFancyUI && !IngameFancyUI.Draw(spriteBatch, _drawInterfaceGameTime))
        {
            result = false;
            DrawPendingMouseText();
        }
        return result;
    }
 
    private bool DrawInterface_11_IngameOptionsMenu()
    {
        bool result = true;
        if (ingameOptionsWindow)
        {
            DrawInterface_16_MapOrMinimap();
            PlayerInput.SetZoom_UI();
            Matrix uIScaleMatrix = UIScaleMatrix;
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, uIScaleMatrix);
            IngameOptions.Draw(this, spriteBatch);
            DrawInterface_40_InteractItemIcon();
            DrawPendingMouseText();
            result = false;
            _MouseOversCanClear = true;
        }
        return result;
    }
 
    private static bool DrawInterface_8_CheckF11UIHideToggle()
    {
        bool result = true;
        if (hideUI)
        {
            maxQ = true;
            result = false;
            _MouseOversCanClear = true;
            DrawPendingMouseText();
        }
        return result;
    }
 
    private static bool DrawInterface_10_CheckCaptureManager()
    {
        bool result = true;
        PlayerInput.SetDesiredZoomContext(ZoomContext.Unscaled_MouseInWorld);
        CaptureManager.Instance.Update();
        if (CaptureManager.Instance.Active)
        {
            CaptureManager.Instance.Draw(spriteBatch);
            result = false;
            _MouseOversCanClear = true;
            PlayerInput.SetZoom_UI();
            Matrix uIScaleMatrix = UIScaleMatrix;
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, uIScaleMatrix);
            DrawPendingMouseText();
        }
        return result;
    }
 
    private static void DrawInterface_9_WireSelection()
    {
        if (!hideUI)
        {
            DrawInterface_Resources_GolfPower();
            DrawInterface_GolfBallIndicator();
        }
        WiresUI.HandleWiresUI(spriteBatch);
    }
 
    private static void DrawInterface_0_InterfaceLogic1()
    {
        if (player[myPlayer].selectedItem == 58 && player[myPlayer].itemAnimation > 0)
        {
            mouseLeftRelease = false;
        }
    }
 
    private void DrawInterface_7_TownNPCHouseBanners()
    {
        if (EquipPage != 1 && (!UILinkPointNavigator.Shortcuts.NPCS_IconsDisplay || !PlayerInput.UsingGamepad))
        {
            return;
        }
        if (ignoreErrors)
        {
            try
            {
                DrawNPCHousesInWorld();
                return;
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                return;
            }
        }
        DrawNPCHousesInWorld();
    }
 
    private static void DrawInterface_6_TileGridOption()
    {
        bool flag = MouseShowBuildingGrid && !SmartCursorIsUsed;
        if (PlayerInput.UsingGamepad && !SmartCursorIsUsed)
        {
            _ = !PlayerInput.UsingGamepadUI;
        }
        else
            _ = 0;
        if (flag && !player[myPlayer].dead && !PlayerInput.CursorIsBusy)
        {
            float num = player[myPlayer].velocity.Length();
            float num2 = 6f;
            float value = MathHelper.Lerp(0f, 0.7f, MathHelper.Clamp(1f - num / num2, 0f, 1f));
            MouseBuildingGridAlpha = MathHelper.Lerp(MouseBuildingGridAlpha, value, 0.2f);
            value = MouseBuildingGridAlpha;
            if (value > 0f)
            {
                Vector2 position = MouseWorld.ToTileCoordinates().ToVector2() * 16f;
                new Vector2(offScreenRange, offScreenRange);
                _ = drawToScreen;
                position -= screenPosition;
                position += new Vector2(8f);
                if (player[myPlayer].gravDir == -1f)
                {
                    position.Y = (float)screenHeight - position.Y;
                }
                Texture2D value2 = TextureAssets.CursorRadial.Value;
                spriteBatch.Draw(value2, position, null, Microsoft.Xna.Framework.Color.White * 0.5f * value, 0f, value2.Size() / 2f, 1f, SpriteEffects.None, 0f);
            }
        }
        else
        {
            MouseBuildingGridAlpha = MathHelper.Clamp(MouseBuildingGridAlpha - 0.05f, 0f, 1f);
        }
    }
 
    private static void DrawInterface_5_GamepadLockOn()
    {
        LockOnHelper.Draw(spriteBatch);
    }
 
    private static void DrawInterface_4_Ruler()
    {
        if (!player[myPlayer].rulerLine || player[myPlayer].builderAccStatus[0] != 0)
        {
            return;
        }
        float num = player[myPlayer].velocity.Length();
        float num2 = 6f;
        float num3 = 2f;
        if (!(num <= num2))
        {
            return;
        }
        float num4 = 1f;
        if (num >= num3)
        {
            num4 = 1f - (num - num3) / num2;
        }
        int num5 = 1;
        if ((float)mouseX + screenPosition.X < player[myPlayer].Center.X)
        {
            num5 = -1;
        }
        int num6 = (int)(player[myPlayer].position.X + (float)(player[myPlayer].width / 2)) / 16;
        int num7 = (int)(player[myPlayer].position.Y + (float)player[myPlayer].height - 2f) / 16;
        if (player[myPlayer].gravDir == -1f)
        {
            num7--;
        }
        Vector2 mouseWorld = MouseWorld;
        if (Math.Abs(num6 - (int)(MouseWorld.X / 16f)) > 0)
        {
            num6 += num5;
        }
        if (player[myPlayer].gravDir == -1f)
        {
            mouseWorld.Y += 16f;
        }
        mouseWorld /= 16f;
        new Vector2(num6, num7);
        int num8 = (int)mouseWorld.X - num6;
        int num9 = (int)mouseWorld.Y - num7;
        Math.Abs(num8);
        Math.Abs(num9);
        rulerLineDisplayValues.X = num8;
        rulerLineDisplayValues.Y = num9;
        if (num8 == 0 && num9 == 0)
        {
            return;
        }
        Texture2D value = TextureAssets.Extra[2].Value;
        Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
        int num10 = num6;
        int num11 = num7;
        if (player[myPlayer].gravDir == -1f)
        {
            num11--;
        }
        float r = 0.24f;
        float g = 0.8f;
        float b = 0.9f;
        float a = 1f;
        float num12 = 0.8f;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(r, g, b, a) * num12 * num4;
        spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(num10, num11) * 16f - screenPosition, 16f), value2, color, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
        if (num8 != 0)
        {
            int num13 = Math.Sign(num8);
            value2.Y = ((num13 == 1) ? 16 : 32);
            while (num8 != 0)
            {
                num8 -= num13;
                num10 += num13;
                if (num8 == 0)
                {
                    value2.Y = 0;
                }
                color = new Microsoft.Xna.Framework.Color(r, g, b, a) * num12 * num4;
                spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(num10, num11) * 16f - screenPosition, 16f), value2, color, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
            }
        }
        if (num9 == 0)
        {
            return;
        }
        int num14 = Math.Sign(num9);
        value2.Y = ((num14 == 1) ? 48 : 64);
        while (num9 != 0)
        {
            num9 -= num14;
            num11 += num14;
            if (num9 == 0)
            {
                value2.Y = 0;
            }
            color = new Microsoft.Xna.Framework.Color(r, g, b, a) * num12 * num4;
            spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(num10, num11) * 16f - screenPosition, 16f), value2, color, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
        }
    }
 
    private static void DrawInterface_3_LaserRuler()
    {
        if (!player[myPlayer].rulerGrid || player[myPlayer].builderAccStatus[1] != 0)
        {
            return;
        }
        float num = player[myPlayer].velocity.Length();
        num = Vector2.Distance(player[myPlayer].position, player[myPlayer].shadowPos[2]);
        float num2 = 6f;
        Texture2D value = TextureAssets.Extra[68].Value;
        float num3 = MathHelper.Lerp(0.2f, 0.7f, MathHelper.Clamp(1f - num / num2, 0f, 1f));
        Vector2 vec = screenPosition;
        vec += new Vector2(-50f);
        vec = vec.ToTileCoordinates().ToVector2() * 16f;
        int num4 = (screenWidth + 100) / 16;
        int num5 = (screenHeight + 100) / 16;
        Microsoft.Xna.Framework.Point point = MouseWorld.ToTileCoordinates();
        point.X -= (int)vec.X / 16;
        point.Y -= (int)vec.Y / 16;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(0.24f, 0.8f, 0.9f, 0.5f) * 0.4f * num3;
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(1f, 0.8f, 0.9f, 0.5f) * 0.5f * num3;
        Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle(0, 18, 18, 18);
        vec -= Vector2.One;
        for (int i = 0; i < num4; i++)
        {
            for (int j = 0; j < num5; j++)
            {
                Microsoft.Xna.Framework.Color color3 = color;
                Vector2 zero = Vector2.Zero;
                if (i != point.X && j != point.Y)
                {
                    if (i != point.X + 1)
                    {
                        value2.X = 0;
                        value2.Width = 16;
                    }
                    else
                    {
                        value2.X = 2;
                        value2.Width = 14;
                        zero.X = 2f;
                    }
                    if (j != point.Y + 1)
                    {
                        value2.Y = 18;
                        value2.Height = 16;
                    }
                    else
                    {
                        value2.Y = 2;
                        value2.Height = 14;
                        zero.Y = 2f;
                    }
                    spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(i, j) * 16f - screenPosition + vec + zero, 16f), value2, color3, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
                }
            }
        }
        value2 = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 18);
        for (int k = 0; k < num4; k++)
        {
            if (k == point.X)
            {
                spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(k, point.Y) * 16f - screenPosition + vec, 16f), new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16), color2, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
            }
            else
            {
                spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(k, point.Y) * 16f - screenPosition + vec, 16f), value2, color2, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
            }
        }
        value2 = new Microsoft.Xna.Framework.Rectangle(0, 0, 18, 16);
        for (int l = 0; l < num5; l++)
        {
            if (l != point.Y)
            {
                spriteBatch.Draw(value, ReverseGravitySupport(new Vector2(point.X, l) * 16f - screenPosition + vec, 16f), value2, color2, 0f, Vector2.Zero, 1f, SpriteEffects.None, 0f);
            }
        }
    }
 
    private static void DrawInterface_2_SmartCursorTargets()
    {
        DrawSmartCursor();
    }
 
    private static void DrawInterface_1_1_DrawEmoteBubblesInWorld()
    {
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, null, null, null, GameViewMatrix.ZoomMatrix);
        EmoteBubble.DrawAll(spriteBatch);
        if (instance.currentNPCShowingChatBubble != -1)
        {
            DrawNPCChatBubble(instance.currentNPCShowingChatBubble);
        }
        instance.currentNPCShowingChatBubble = -1;
    }
 
    private static void DrawInterface_1_2_DrawEntityMarkersInWorld()
    {
        Player localPlayer = LocalPlayer;
        if (localPlayer.dead || !localPlayer.HeldItem.summon)
        {
            return;
        }
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, null, null, null, GameViewMatrix.ZoomMatrix);
        Texture2D value = TextureAssets.Extra[199].Value;
        Vector2 zero = Vector2.Zero;
        int minionAttackTargetNPC = localPlayer.MinionAttackTargetNPC;
        Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X, (int)screenPosition.Y, screenWidth, screenHeight);
        for (int i = 0; i < 200; i++)
        {
            NPC nPC = npc[i];
            if (nPC.active && nPC.Hitbox.Intersects(value2))
            {
                Vector2 vector = nPC.Center - screenPosition;
                if (player[myPlayer].gravDir == -1f)
                {
                    vector.Y = (float)screenHeight - vector.Y;
                }
                Vector2 position = vector + zero;
                if (i == minionAttackTargetNPC)
                {
                    int frameY = (int)(GlobalTimeWrappedHourly * 10f) % 4;
                    Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, 4, 0, frameY, 0, -2);
                    Vector2 origin = rectangle.Size() / 2f;
                    Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White * 0.7f;
                    color.A /= 2;
                    spriteBatch.Draw(value, position, rectangle, color, 0f, origin, 1f, SpriteEffects.None, 0f);
                }
            }
        }
    }
 
    private static void MouseOversTryToClear()
    {
        if (_MouseOversCanClear)
        {
            _MouseOversCanClear = false;
            MouseOversClear();
        }
    }
 
    private static void MouseOversClear()
    {
        player[myPlayer].cursorItemIconEnabled = false;
        player[myPlayer].cursorItemIconID = 0;
        player[myPlayer].cursorItemIconText = string.Empty;
        player[myPlayer].cursorItemIconPush = 0;
        signHover = -1;
    }
 
    public static void ItemIconCacheUpdate(int selectedItemID)
    {
        _itemIconCacheScreenPosition = MouseScreen;
        _itemIconCacheSelectedItemID = selectedItemID;
        _itemIconCacheTime = 10;
    }
 
    public static void ItemIconCacheVerification()
    {
        if (_itemIconCacheTime > 0)
        {
            float num = Vector2.Distance(_itemIconCacheScreenPosition, MouseScreen);
            if (num != 0f)
            {
                _itemIconCacheTime--;
            }
            if (num > 4f)
            {
                _itemIconCacheTime = 0;
            }
            if (_itemIconCacheSelectedItemID != player[myPlayer].inventory[player[myPlayer].selectedItem].type)
            {
                _itemIconCacheTime = 0;
            }
        }
    }
 
    public static void DrawWallOfFish()
    {
        List<int> list = new List<int>();
        for (int i = 2297; i <= 2321; i++)
        {
            list.Add(i);
        }
        for (int j = 2450; j <= 2488; j++)
        {
            list.Add(j);
        }
        for (int k = 0; k < 5; k++)
        {
            float num = 10f;
            Vector2 vector = new Vector2((float)screenWidth / num * (GlobalTimeWrappedHourly % num), -100f);
            vector.X += 14 * k;
            vector.Y += k % 2 * 14;
            int num2 = 30 * k;
            while (vector.Y < (float)(screenHeight + 100))
            {
                if (++num2 >= list.Count)
                {
                    num2 = 0;
                }
                vector.Y += 26f;
                instance.LoadItem(list[num2]);
                Texture2D value = TextureAssets.Item[list[num2]].Value;
                Microsoft.Xna.Framework.Point point = (vector + screenPosition).ToTileCoordinates();
                spriteBatch.Draw(value, vector, null, Lighting.GetColor(point.X, point.Y), (float)Math.PI / 4f, value.Size() / 2f, 1f, SpriteEffects.None, 0f);
            }
        }
    }
 
    public static void DrawWallOfStars()
    {
        bool flag = true;
        if (flag)
        {
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        }
        int num = Projectile.NewProjectile(Projectile.GetNoneSource(), Vector2.Zero, Vector2.UnitX, 12, 0, 0f, myPlayer);
        Projectile projectile = Main.projectile[num];
        for (int i = 0; i < 5; i++)
        {
            float num2 = 10f;
            Vector2 vector = new Vector2((float)screenWidth / num2 * (GlobalTimeWrappedHourly % num2), -100f);
            vector.X += 14 * i;
            vector.Y += i % 2 * 14;
            while (vector.Y < (float)(screenHeight + 100))
            {
                vector.Y += 26f;
                projectile.position = Vector2.One * 10f;
                projectile.velocity = Vector2.UnitX * 10f;
                projectile.rotation = GlobalTimeWrappedHourly * ((float)Math.PI * 2f);
                projectile.Update(num);
                projectile.position = vector + screenPosition;
                instance.DrawProj(num);
            }
        }
        projectile.position = Vector2.One * 10f;
        projectile.Kill();
        if (flag)
        {
            spriteBatch.End();
        }
    }
 
    private static void DrawSmartCursor()
    {
        if (SmartCursorShowing && !player[myPlayer].dead)
        {
            Vector2 vector = new Vector2(SmartCursorX, SmartCursorY) * 16f;
            new Vector2(offScreenRange, offScreenRange);
            _ = drawToScreen;
            vector -= screenPosition;
            if (player[myPlayer].gravDir == -1f)
            {
                vector.Y = (float)screenHeight - vector.Y - 16f;
            }
            Microsoft.Xna.Framework.Color newColor = Lighting.GetColor(SmartCursorX, SmartCursorY) * 1f;
            Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1);
            float r = 1f;
            float g = 0.9f;
            float b = 0.1f;
            float a = 1f;
            float num = 0.6f;
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitX * 8f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitY * 8f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.One * 8f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            b = 0.3f;
            g = 0.95f;
            a = (num = 1f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitX * -2f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(2f, 16f), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitX * 16f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(2f, 16f), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitY * -2f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(16f, 2f), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitY * 16f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(16f, 2f), SpriteEffects.None, 0f);
        }
    }
 
    private static void DrawSmartInteract()
    {
        if (SmartInteractShowingGenuine && SmartInteractNPC == -1 && SmartInteractProj == -1 && !player[myPlayer].dead)
        {
            Vector2 vector = new Vector2(SmartInteractX, SmartInteractY) * 16f;
            new Vector2(offScreenRange, offScreenRange);
            _ = drawToScreen;
            vector -= screenPosition;
            if (player[myPlayer].gravDir == -1f)
            {
                vector.Y = (float)screenHeight - vector.Y - 16f;
            }
            Microsoft.Xna.Framework.Color newColor = Lighting.GetColor(SmartInteractX, SmartInteractY) * 1f;
            Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1);
            float r = 0.1f;
            float g = 0.9f;
            float b = 1f;
            float a = 1f;
            float num = 0.6f;
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitX * 8f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitY * 8f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.One * 8f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, 8f, SpriteEffects.None, 0f);
            r = 0.3f;
            g = 0.95f;
            a = (num = 1f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitX * -2f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(2f, 16f), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitX * 16f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(2f, 16f), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitY * -2f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(16f, 2f), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector + Vector2.UnitY * 16f, value, buffColor(newColor, r, g, b, a) * num, 0f, Vector2.Zero, new Vector2(16f, 2f), SpriteEffects.None, 0f);
        }
    }
 
    private void DrawInterface_30_Hotbar()
    {
        try
        {
            GUIHotbarDrawInner();
        }
        catch (Exception e)
        {
            if (ignoreErrors)
            {
                TimeLogger.DrawException(e);
                return;
            }
            throw;
        }
    }
 
    public void GUIChatDraw()
    {
        if (ignoreErrors)
        {
            try
            {
                if ((npcChatText != "" || player[myPlayer].sign != -1) && !editChest)
                {
                    GUIChatDrawInner();
                }
                return;
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                return;
            }
        }
        if ((npcChatText != "" || player[myPlayer].sign != -1) && !editChest)
        {
            GUIChatDrawInner();
        }
    }
 
    public static void DrawItemIcon(SpriteBatch spriteBatch, Item theItem, Vector2 screenPositionForItemCenter, Microsoft.Xna.Framework.Color itemLightColor, float sizeLimit)
    {
        GetItemDrawFrame(theItem.type, out var itemTexture, out var frame);
        ItemSlot.DrawItem_GetColorAndScale(theItem, theItem.scale, ref itemLightColor, sizeLimit, ref frame, out var itemLight, out var finalDrawScale);
        spriteBatch.Draw(itemTexture, screenPositionForItemCenter, frame, itemLight, 0f, frame.Size() / 2f, finalDrawScale, SpriteEffects.None, 0f);
        if (theItem.color != Microsoft.Xna.Framework.Color.Transparent)
        {
            spriteBatch.Draw(itemTexture, screenPositionForItemCenter, frame, theItem.GetColor(itemLightColor), 0f, frame.Size() / 2f, finalDrawScale, SpriteEffects.None, 0f);
        }
    }
 
    private void DrawInfoAccs()
    {
        if (!CanShowInfoAccs)
        {
            return;
        }
        bool flag = false;
        bool flag2 = false;
        bool flag3 = false;
        bool flag4 = false;
        bool flag5 = false;
        bool flag6 = false;
        bool flag7 = false;
        bool flag8 = false;
        bool flag9 = false;
        bool flag10 = false;
        bool flag11 = false;
        bool flag12 = false;
        int num = -1;
        int num2 = -10;
        int num3 = 0;
        string text = "";
        float num4 = 215f;
        int startX = 0;
        if (GameCulture.FromCultureName(GameCulture.CultureName.Russian).IsActive)
        {
            startX = -50;
            num4 += 50f;
        }
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(100, 100, 100, mouseTextColor);
        for (int i = 0; i < 12; i++)
        {
            string text2 = "";
            string text3 = "";
            Microsoft.Xna.Framework.Color infoTextColor = new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor);
            Microsoft.Xna.Framework.Color infoTextShadowColor = Microsoft.Xna.Framework.Color.Black;
            if (player[myPlayer].accWatch > 0 && !flag && (!player[myPlayer].hideInfo[0] || playerInventory))
            {
                num = 0;
                text3 = Lang.inter[95].Value;
                string textValue = Language.GetTextValue("GameUI.TimeAtMorning");
                double num5 = time;
                if (!dayTime)
                {
                    num5 += 54000.0;
                }
                num5 = num5 / 86400.0 * 24.0;
                double num6 = 7.5;
                num5 = num5 - num6 - 12.0;
                if (num5 < 0.0)
                {
                    num5 += 24.0;
                }
                if (num5 >= 12.0)
                {
                    textValue = Language.GetTextValue("GameUI.TimePastMorning");
                }
                int num7 = (int)num5;
                double num8 = num5 - (double)num7;
                num8 = (int)(num8 * 60.0);
                string text4 = string.Concat(num8);
                if (num8 < 10.0)
                {
                    text4 = "0" + text4;
                }
                if (num7 > 12)
                {
                    num7 -= 12;
                }
                if (num7 == 0)
                {
                    num7 = 12;
                }
                if (player[myPlayer].accWatch == 1)
                {
                    text4 = "00";
                }
                else if (player[myPlayer].accWatch == 2)
                {
                    text4 = ((!(num8 < 30.0)) ? "30" : "00");
                }
                text2 = num7 + ":" + text4 + " " + textValue;
                flag = true;
            }
            else if (player[myPlayer].accWeatherRadio && !flag5 && (!player[myPlayer].hideInfo[1] || playerInventory))
            {
                num = 1;
                text3 = Lang.inter[96].Value;
                string text5 = "";
                text5 = (IsItStorming ? Language.GetTextValue("GameUI.Storm") : (((double)maxRaining > 0.6) ? Language.GetTextValue("GameUI.HeavyRain") : (((double)maxRaining >= 0.2) ? Language.GetTextValue("GameUI.Rain") : ((maxRaining > 0f) ? Language.GetTextValue("GameUI.LightRain") : ((cloudBGActive > 0f) ? Language.GetTextValue("GameUI.Overcast") : ((numClouds > 90) ? Language.GetTextValue("GameUI.MostlyCloudy") : ((numClouds > 55) ? Language.GetTextValue("GameUI.Cloudy") : ((numClouds <= 15) ? Language.GetTextValue("GameUI.Clear") : Language.GetTextValue("GameUI.PartlyCloudy")))))))));
                text2 = text5;
                int num9 = (int)(windSpeedCurrent * 50f);
                if (num9 < 0)
                {
                    text2 += Language.GetTextValue("GameUI.EastWind", Math.Abs(num9));
                }
                else if (num9 > 0)
                {
                    text2 += Language.GetTextValue("GameUI.WestWind", num9);
                }
                if (Sandstorm.Happening)
                {
                    if (GlobalTimeWrappedHourly % 10f >= 5f)
                    {
                        text2 = Language.GetTextValue("GameUI.Sandstorm");
                    }
                    text2 += " +";
                }
                flag5 = true;
            }
            else if (player[myPlayer].accCalendar && !flag8 && (!player[myPlayer].hideInfo[7] || playerInventory))
            {
                num = ((bloodMoon && !dayTime) ? 8 : ((!eclipse || !dayTime) ? 7 : 8));
                text3 = Lang.inter[102].Value;
                if (moonPhase == 0)
                {
                    text2 = Language.GetTextValue("GameUI.FullMoon");
                }
                else if (moonPhase == 1)
                {
                    text2 = Language.GetTextValue("GameUI.WaningGibbous");
                }
                else if (moonPhase == 2)
                {
                    text2 = Language.GetTextValue("GameUI.ThirdQuarter");
                }
                else if (moonPhase == 3)
                {
                    text2 = Language.GetTextValue("GameUI.WaningCrescent");
                }
                else if (moonPhase == 4)
                {
                    text2 = Language.GetTextValue("GameUI.NewMoon");
                }
                else if (moonPhase == 5)
                {
                    text2 = Language.GetTextValue("GameUI.WaxingCrescent");
                }
                else if (moonPhase == 6)
                {
                    text2 = Language.GetTextValue("GameUI.FirstQuarter");
                }
                else if (moonPhase == 7)
                {
                    text2 = Language.GetTextValue("GameUI.WaxingGibbous");
                }
                flag8 = true;
            }
            else if (player[myPlayer].accFishFinder && !flag4 && (!player[myPlayer].hideInfo[2] || playerInventory))
            {
                bool flag13 = false;
                num = 2;
                text3 = Lang.inter[97].Value;
                for (int j = 0; j < 1000; j++)
                {
                    if (projectile[j].active && projectile[j].owner == myPlayer && projectile[j].bobber)
                    {
                        flag13 = true;
                        break;
                    }
                }
                if (flag13)
                {
                    text2 = player[myPlayer].displayedFishingInfo;
                }
                else
                {
                    PlayerFishingConditions fishingConditions = player[myPlayer].GetFishingConditions();
                    text2 = ((fishingConditions.BaitItemType != 2673) ? (player[myPlayer].displayedFishingInfo = Language.GetTextValue("GameUI.FishingPower", fishingConditions.FinalFishingLevel)) : Language.GetTextValue("GameUI.FishingWarning"));
                }
                flag4 = true;
            }
            else if (player[myPlayer].accOreFinder && !flag10 && (!player[myPlayer].hideInfo[10] || playerInventory))
            {
                num = 10;
                text3 = Lang.inter[104].Value;
                if (SceneMetrics.bestOre <= 0)
                {
                    text2 = Language.GetTextValue("GameUI.NoTreasureNearby");
                    infoTextColor = color;
                }
                else
                {
                    int baseOption = 0;
                    int num10 = SceneMetrics.bestOre;
                    if (SceneMetrics.ClosestOrePosition.HasValue)
                    {
                        Microsoft.Xna.Framework.Point value = SceneMetrics.ClosestOrePosition.Value;
                        Tile tileSafely = Framing.GetTileSafely(value);
                        if (tileSafely.active())
                        {
                            MapHelper.GetTileBaseOption(value.X, value.Y, tileSafely.type, tileSafely, ref baseOption);
                            num10 = tileSafely.type;
                            if (TileID.Sets.BasicChest[num10] || TileID.Sets.BasicChestFake[num10])
                            {
                                baseOption = 0;
                            }
                        }
                    }
                    text2 = Language.GetTextValue("GameUI.OreDetected", Lang.GetMapObjectName(MapHelper.TileToLookup(num10, baseOption)));
                }
                flag10 = true;
            }
            else if (player[myPlayer].accCritterGuide && !flag11 && (!player[myPlayer].hideInfo[11] || playerInventory))
            {
                flag11 = true;
                num = 11;
                text3 = Lang.inter[105].Value;
                int num11 = 1300;
                int num12 = 0;
                int num13 = -1;
                if (player[myPlayer].accCritterGuideCounter <= 0)
                {
                    player[myPlayer].accCritterGuideCounter = 15;
                    for (int k = 0; k < 200; k++)
                    {
                        if (npc[k].active && npc[k].rarity > num12 && (npc[k].Center - player[myPlayer].Center).Length() < (float)num11)
                        {
                            num13 = k;
                            num12 = npc[k].rarity;
                        }
                    }
                    player[myPlayer].accCritterGuideNumber = (byte)num13;
                }
                else
                {
                    player[myPlayer].accCritterGuideCounter--;
                    num13 = player[myPlayer].accCritterGuideNumber;
                }
                if (num13 >= 0 && num13 < 200 && npc[num13].active && npc[num13].rarity > 0)
                {
                    text2 = npc[num13].GivenOrTypeName;
                    DrawInfoAccs_AdjustInfoTextColorsForNPC(npc[num13], ref infoTextColor, ref infoTextShadowColor);
                }
                else
                {
                    text2 = Language.GetTextValue("GameUI.NoRareCreatures");
                    infoTextColor = color;
                }
            }
            else if (player[myPlayer].accThirdEye && !flag6 && (!player[myPlayer].hideInfo[5] || playerInventory))
            {
                flag6 = true;
                num = 5;
                text3 = Lang.inter[100].Value;
                int num14 = 2000;
                if (player[myPlayer].accThirdEyeCounter == 0)
                {
                    player[myPlayer].accThirdEyeNumber = 0;
                    player[myPlayer].accThirdEyeCounter = 15;
                    for (int l = 0; l < 200; l++)
                    {
                        if (npc[l].active && !npc[l].friendly && npc[l].damage > 0 && npc[l].lifeMax > 5 && !npc[l].dontCountMe && (npc[l].Center - player[myPlayer].Center).Length() < (float)num14)
                        {
                            player[myPlayer].accThirdEyeNumber++;
                        }
                    }
                }
                else
                {
                    player[myPlayer].accThirdEyeCounter--;
                }
                if (player[myPlayer].accThirdEyeNumber != 0)
                {
                    text2 = ((player[myPlayer].accThirdEyeNumber != 1) ? Language.GetTextValue("GameUI.EnemiesNearby", player[myPlayer].accThirdEyeNumber) : Language.GetTextValue("GameUI.OneEnemyNearby"));
                }
                else
                {
                    text2 = Language.GetTextValue("GameUI.NoEnemiesNearby");
                    infoTextColor = color;
                }
            }
            else if (player[myPlayer].accJarOfSouls && !flag7 && (!player[myPlayer].hideInfo[6] || playerInventory))
            {
                flag7 = true;
                num = 6;
                text3 = Lang.inter[101].Value;
                int lastCreatureHit = player[myPlayer].lastCreatureHit;
                if (lastCreatureHit <= 0)
                {
                    text2 = Language.GetTextValue("GameUI.NoKillCount");
                    infoTextColor = color;
                }
                else
                {
                    text2 = Lang.GetNPCNameValue(Item.BannerToNPC(lastCreatureHit)) + ": " + NPC.killCount[lastCreatureHit];
                }
            }
            else if (player[myPlayer].accDreamCatcher && !flag12 && (!player[myPlayer].hideInfo[12] || playerInventory))
            {
                num = 12;
                text3 = Lang.inter[106].Value;
                player[myPlayer].checkDPSTime();
                int dPS = player[myPlayer].getDPS();
                flag12 = true;
                if (dPS == 0)
                {
                    text2 = Language.GetTextValue("GameUI.NoDPS");
                    infoTextColor = color;
                }
                else
                {
                    text2 = Language.GetTextValue("GameUI.DPS", player[myPlayer].getDPS());
                }
            }
            else if (player[myPlayer].accStopwatch && !flag9 && (!player[myPlayer].hideInfo[9] || playerInventory))
            {
                num = 9;
                text3 = Lang.inter[103].Value;
                Vector2 vector = player[myPlayer].velocity + player[myPlayer].instantMovementAccumulatedThisFrame;
                if (player[myPlayer].mount.Active && player[myPlayer].mount.IsConsideredASlimeMount && player[myPlayer].velocity.Y != 0f && !player[myPlayer].SlimeDontHyperJump)
                {
                    vector.Y += player[myPlayer].velocity.Y;
                }
                int num15 = (int)(1f + vector.Length() * 6f);
                if (num15 > player[myPlayer].speedSlice.Length)
                {
                    num15 = player[myPlayer].speedSlice.Length;
                }
                float num16 = 0f;
                for (int num17 = num15 - 1; num17 > 0; num17--)
                {
                    player[myPlayer].speedSlice[num17] = player[myPlayer].speedSlice[num17 - 1];
                }
                player[myPlayer].speedSlice[0] = vector.Length();
                for (int m = 0; m < player[myPlayer].speedSlice.Length; m++)
                {
                    if (m < num15)
                    {
                        num16 += player[myPlayer].speedSlice[m];
                    }
                    else
                    {
                        player[myPlayer].speedSlice[m] = num16 / (float)num15;
                    }
                }
                num16 /= (float)num15;
                int num18 = 42240;
                int num19 = 216000;
                float num20 = num16 * (float)num19 / (float)num18;
                if (!player[myPlayer].merman && !player[myPlayer].ignoreWater)
                {
                    if (player[myPlayer].honeyWet)
                    {
                        num20 /= 4f;
                    }
                    else if (player[myPlayer].wet)
                    {
                        num20 /= 2f;
                    }
                }
                text2 = Language.GetTextValue("GameUI.Speed", Math.Round(num20));
                flag9 = true;
            }
            else if (player[myPlayer].accCompass > 0 && !flag3 && (!player[myPlayer].hideInfo[3] || playerInventory))
            {
                num = 3;
                text3 = Lang.inter[98].Value;
                int num21 = (int)((player[myPlayer].position.X + (float)(player[myPlayer].width / 2)) * 2f / 16f - (float)maxTilesX);
                text2 = ((num21 > 0) ? Language.GetTextValue("GameUI.CompassEast", num21) : ((num21 >= 0) ? Language.GetTextValue("GameUI.CompassCenter") : Language.GetTextValue("GameUI.CompassWest", -num21)));
                flag3 = true;
            }
            else if (player[myPlayer].accDepthMeter > 0 && !flag2 && (!player[myPlayer].hideInfo[4] || playerInventory))
            {
                num = 4;
                text3 = Lang.inter[99].Value;
                int num22 = (int)((double)((player[myPlayer].position.Y + (float)player[myPlayer].height) * 2f / 16f) - worldSurface * 2.0);
                string text6 = "";
                float num23 = (float)maxTilesX / 4200f;
                num23 *= num23;
                int num24 = 1200;
                float num25 = (float)((double)(player[myPlayer].Center.Y / 16f - (65f + 10f * num23)) / (worldSurface / 5.0));
                text6 = ((player[myPlayer].position.Y > (float)((maxTilesY - 204) * 16)) ? Language.GetTextValue("GameUI.LayerUnderworld") : (((double)player[myPlayer].position.Y > rockLayer * 16.0 + (double)(num24 / 2) + 16.0) ? Language.GetTextValue("GameUI.LayerCaverns") : ((num22 > 0) ? Language.GetTextValue("GameUI.LayerUnderground") : ((!(num25 >= 1f)) ? Language.GetTextValue("GameUI.LayerSpace") : Language.GetTextValue("GameUI.LayerSurface")))));
                string text7 = "";
                num22 = Math.Abs(num22);
                text7 = ((num22 != 0) ? Language.GetTextValue("GameUI.Depth", num22) : Language.GetTextValue("GameUI.DepthLevel"));
                text2 = text7 + " " + text6;
                flag2 = true;
            }
            if (!(text2 != ""))
            {
                continue;
            }
            GetInfoAccIconPosition(num3, startX, out var X, out var Y);
            if (num >= 0)
            {
                num3++;
                int num26 = 22;
                if (screenHeight < 650)
                {
                    num26 = 20;
                }
                Vector2 vector2 = new Vector2(X, Y + 74 + num26 * i + 52);
                int num27 = num;
                if (num27 == 8)
                {
                    num27 = 7;
                }
                Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.White;
                bool flag14 = false;
                if (playerInventory)
                {
                    vector2 = new Vector2(X, Y);
                    if ((float)mouseX >= vector2.X && (float)mouseY >= vector2.Y && (float)mouseX <= vector2.X + (float)TextureAssets.InfoIcon[num].Width() && (float)mouseY <= vector2.Y + (float)TextureAssets.InfoIcon[num].Height() && !PlayerInput.IgnoreMouseInterface)
                    {
                        flag14 = true;
                        player[myPlayer].mouseInterface = true;
                        if (mouseLeft && mouseLeftRelease)
                        {
                            SoundEngine.PlaySound(12);
                            mouseLeftRelease = false;
                            player[myPlayer].hideInfo[num27] = !player[myPlayer].hideInfo[num27];
                        }
                        if (!mouseText)
                        {
                            text = text3;
                            mouseText = true;
                        }
                    }
                    if (player[myPlayer].hideInfo[num27])
                    {
                        color2 = new Microsoft.Xna.Framework.Color(80, 80, 80, 70);
                    }
                }
                else if ((float)mouseX >= vector2.X && (float)mouseY >= vector2.Y && (float)mouseX <= vector2.X + (float)TextureAssets.InfoIcon[num].Width() && (float)mouseY <= vector2.Y + (float)TextureAssets.InfoIcon[num].Height() && !mouseText)
                {
                    num2 = i;
                    text = text3;
                    mouseText = true;
                }
                UILinkPointNavigator.SetPosition(1558 + num3 - 1, vector2 + TextureAssets.InfoIcon[num].Value.Size() * 0.75f);
                spriteBatch.Draw(TextureAssets.InfoIcon[num].Value, vector2, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.InfoIcon[num].Width(), TextureAssets.InfoIcon[num].Height()), color2, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                if (flag14)
                {
                    spriteBatch.Draw(TextureAssets.InfoIcon[13].Value, vector2 - Vector2.One * 2f, null, OurFavoriteColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                }
                X += 20;
            }
            UILinkPointNavigator.Shortcuts.INFOACCCOUNT = num3;
            if (playerInventory)
            {
                continue;
            }
            Vector2 vector3 = new Vector2(1f);
            Vector2 vector4 = FontAssets.MouseText.Value.MeasureString(text2);
            if (vector4.X > num4)
            {
                vector3.X = num4 / vector4.X;
            }
            if (vector3.X < 0.58f)
            {
                vector3.Y = 1f - vector3.X / 3f;
            }
            for (int n = 0; n < 5; n++)
            {
                int num28 = 0;
                int num29 = 0;
                Microsoft.Xna.Framework.Color color3 = infoTextShadowColor;
                if (n == 0)
                {
                    num28 = -2;
                }
                if (n == 1)
                {
                    num28 = 2;
                }
                if (n == 2)
                {
                    num29 = -2;
                }
                if (n == 3)
                {
                    num29 = 2;
                }
                if (n == 4)
                {
                    color3 = infoTextColor;
                }
                if (i > num2 && i < num2 + 2)
                {
                    color3 = new Microsoft.Xna.Framework.Color(color3.R / 3, color3.G / 3, color3.B / 3, color3.A / 3);
                }
                int num30 = 22;
                if (screenHeight < 650)
                {
                    num30 = 20;
                }
                DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text2, new Vector2(X + num28, Y + 74 + num30 * i + num29 + 48), color3, 0f, default(Vector2), vector3, SpriteEffects.None, 0f);
            }
        }
        if (!string.IsNullOrEmpty(text))
        {
            if (playerInventory)
            {
                player[myPlayer].mouseInterface = true;
            }
            MouseText(text, 0, 0);
        }
    }
 
    private void DrawInfoAccs_AdjustInfoTextColorsForNPC(NPC npc, ref Microsoft.Xna.Framework.Color infoTextColor, ref Microsoft.Xna.Framework.Color infoTextShadowColor)
    {
        for (int i = 0; i < NPCID.Sets.GoldCrittersCollection.Count; i++)
        {
            int num = NPCID.Sets.GoldCrittersCollection[i];
            if (npc.type == num)
            {
                infoTextColor = OurFavoriteColor;
                infoTextShadowColor = infoTextColor * 0.1f;
                byte a = (infoTextShadowColor.A = mouseTextColor);
                infoTextColor.A = a;
                break;
            }
        }
    }
 
    private static void GetInfoAccIconPosition(int drawnCount, int StartX, out int X, out int Y)
    {
        if (!playerInventory)
        {
            X = screenWidth - 280;
            Y = -32;
            if (mapStyle == 1 && mapEnabled)
            {
                Y += 261;
            }
        }
        else if (ShouldDrawInfoIconsHorizontally)
        {
            X = screenWidth - 280 + 20 * drawnCount - 10;
            Y = 94;
            if (mapStyle == 1 && mapEnabled)
            {
                Y += 261;
            }
        }
        else
        {
            int num = (int)(52f * inventoryScale);
            float num2 = 0.85f;
            int num3 = (int)(52f * num2);
            int nPCS_IconsPerColumn = UILinkPointNavigator.Shortcuts.NPCS_IconsPerColumn;
            int nPCS_IconsTotal = UILinkPointNavigator.Shortcuts.NPCS_IconsTotal;
            int num4 = (int)Math.Ceiling((float)nPCS_IconsTotal / (float)nPCS_IconsPerColumn);
            int num5 = nPCS_IconsTotal - Math.Max(0, (num4 - 1) * nPCS_IconsPerColumn);
            int num6 = nPCS_IconsPerColumn - num5;
            int num7 = Math.Max(0, num4 - 4);
            if (num4 >= 4 && num6 < 5)
            {
                num7++;
            }
            int num8 = num7 * (num3 + 4);
            if (EquipPage != 1)
            {
                num8 = 0;
            }
            X = 697 - num * 4 + screenWidth - 800 + 20 * (drawnCount % 2) - num8;
            Y = 114 + mH + num * 7 + num / 2 + 20 * (drawnCount / 2) + 8 * (drawnCount / 4) - 20;
            if (EquipPage == 2)
            {
                X += num + num / 2;
                Y -= num;
            }
        }
        X += StartX;
    }
 
    private void DrawBuilderAccToggles(Vector2 start)
    {
        if (!playerInventory)
        {
            return;
        }
        string.IsNullOrEmpty(npcChatText);
        if (false || Main.player[myPlayer].sign >= 0)
        {
            return;
        }
        int num = 0;
        Player player = Main.player[myPlayer];
        int[] builderAccStatus = Main.player[myPlayer].builderAccStatus;
        GetBuilderAccsCountToShow(player, out var blockReplaceIcons, out var torchGodIcons, out var totalDrawnIcons);
        start.Y += 24 * torchGodIcons;
        bool flag = totalDrawnIcons >= 10;
        int num2 = 10;
        for (int i = 0; i < num2; i++)
        {
            int num3 = i - 2;
            switch (i)
            {
            case 0:
                num3 = 8;
                break;
            case 1:
                num3 = 9;
                break;
            }
            Texture2D value = TextureAssets.BuilderAcc.Value;
            Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(0, 16, 14, 14);
            Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White;
            Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(127, 127, 127);
            Vector2 vector = start + new Vector2(0f, num * 24);
            if (flag)
            {
                vector.Y -= 24f;
            }
            bool flag2 = Utils.CenteredRectangle(vector, new Vector2(14f)).Contains(MouseScreen.ToPoint()) && !PlayerInput.IgnoreMouseInterface;
            bool flag3 = flag2 && mouseLeft && mouseLeftRelease;
            switch (num3)
            {
            case 8:
                if (!player.InfoAccMechShowWires)
                {
                    continue;
                }
                rectangle.X = num3 * 16;
                color = ((builderAccStatus[num3] == 0) ? color : color2);
                if (flag2)
                {
                    player.mouseInterface = true;
                    MouseText((builderAccStatus[num3] == 0) ? Language.GetTextValue("GameUI.WireModeForced") : Language.GetTextValue("GameUI.WireModeNormal"), 0, 0);
                    mouseText = true;
                }
                if (flag3)
                {
                    builderAccStatus[num3] = ((builderAccStatus[num3] == 0) ? 1 : 0);
                    SoundEngine.PlaySound(12);
                    mouseLeftRelease = false;
                }
                break;
            case 0:
                if (!player.rulerLine)
                {
                    continue;
                }
                rectangle.X = num3 * 16;
                color = ((builderAccStatus[num3] == 0) ? color : color2);
                if (flag2)
                {
                    player.mouseInterface = true;
                    MouseText((builderAccStatus[num3] == 0) ? Language.GetTextValue("GameUI.RulerOn") : Language.GetTextValue("GameUI.RulerOff"), 0, 0);
                    mouseText = true;
                }
                if (flag3)
                {
                    builderAccStatus[num3] = ((builderAccStatus[num3] == 0) ? 1 : 0);
                    SoundEngine.PlaySound(12);
                    mouseLeftRelease = false;
                }
                break;
            case 1:
                if (!player.rulerGrid)
                {
                    continue;
                }
                rectangle.X = num3 * 16;
                color = ((builderAccStatus[num3] == 0) ? color : color2);
                if (flag2)
                {
                    player.mouseInterface = true;
                    MouseText((builderAccStatus[num3] == 0) ? Language.GetTextValue("GameUI.MechanicalRulerOn") : Language.GetTextValue("GameUI.MechanicalRulerOff"), 0, 0);
                    mouseText = true;
                }
                if (flag3)
                {
                    builderAccStatus[num3] = ((builderAccStatus[num3] == 0) ? 1 : 0);
                    SoundEngine.PlaySound(12);
                    mouseLeftRelease = false;
                }
                break;
            case 3:
                if (!player.autoPaint)
                {
                    continue;
                }
                rectangle.X = num3 * 16;
                color = ((builderAccStatus[num3] == 0) ? color : color2);
                if (flag2)
                {
                    player.mouseInterface = true;
                    MouseText((builderAccStatus[num3] == 0) ? Language.GetTextValue("GameUI.PaintSprayerOn") : Language.GetTextValue("GameUI.PaintSprayerOff"), 0, 0);
                    mouseText = true;
                }
                if (flag3)
                {
                    builderAccStatus[num3] = ((builderAccStatus[num3] == 0) ? 1 : 0);
                    SoundEngine.PlaySound(12);
                    mouseLeftRelease = false;
                }
                break;
            case 2:
                if (!player.autoActuator)
                {
                    continue;
                }
                rectangle.X = num3 * 16;
                color = ((builderAccStatus[num3] == 0) ? color : color2);
                if (flag2)
                {
                    player.mouseInterface = true;
                    MouseText((builderAccStatus[num3] == 0) ? Language.GetTextValue("GameUI.ActuationDeviceOn") : Language.GetTextValue("GameUI.ActuationDeviceOff"), 0, 0);
                    mouseText = true;
                }
                if (flag3)
                {
                    builderAccStatus[num3] = ((builderAccStatus[num3] == 0) ? 1 : 0);
                    SoundEngine.PlaySound(12);
                    mouseLeftRelease = false;
                }
                break;
            case 4:
            case 5:
            case 6:
            case 7:
            case 9:
                if (!player.InfoAccMechShowWires)
                {
                    continue;
                }
                rectangle.X = num3 * 16;
                color = ((builderAccStatus[num3] == 0) ? color : ((builderAccStatus[num3] == 1) ? color2 : ((builderAccStatus[num3] == 2) ? color2.MultiplyRGBA(new Microsoft.Xna.Framework.Color(0.66f, 0.66f, 0.66f, 0.66f)) : color2.MultiplyRGBA(new Microsoft.Xna.Framework.Color(0.33f, 0.33f, 0.33f, 0.33f)))));
                if (flag2)
                {
                    player.mouseInterface = true;
                    string arg = "";
                    switch (num3)
                    {
                    case 4:
                        arg = Language.GetTextValue("Game.RedWires");
                        break;
                    case 5:
                        arg = Language.GetTextValue("Game.BlueWires");
                        break;
                    case 6:
                        arg = Language.GetTextValue("Game.GreenWires");
                        break;
                    case 7:
                        arg = Language.GetTextValue("Game.YellowWires");
                        break;
                    case 9:
                        arg = Language.GetTextValue("Game.Actuators");
                        break;
                    }
                    string arg2 = "";
                    switch (builderAccStatus[num3])
                    {
                    case 0:
                        arg2 = Language.GetTextValue("GameUI.Bright");
                        break;
                    case 1:
                        arg2 = Language.GetTextValue("GameUI.Normal");
                        break;
                    case 2:
                        arg2 = Language.GetTextValue("GameUI.Faded");
                        break;
                    case 3:
                        arg2 = Language.GetTextValue("GameUI.Hidden");
                        break;
                    }
                    MouseText($"{arg}: {arg2}", 0, 0);
                    mouseText = true;
                }
                if (flag3)
                {
                    builderAccStatus[num3]++;
                    if (builderAccStatus[num3] >= 3)
                    {
                        builderAccStatus[num3] = 0;
                    }
                    SoundEngine.PlaySound(12);
                    mouseLeftRelease = false;
                }
                break;
            case 11:
                continue;
            }
            spriteBatch.Draw(value, vector, rectangle, color, 0f, rectangle.Size() / 2f, 1f, SpriteEffects.None, 0f);
            if (flag2)
            {
                spriteBatch.Draw(TextureAssets.InfoIcon[13].Value, vector, null, OurFavoriteColor, 0f, TextureAssets.InfoIcon[13].Value.Size() / 2f, 1f, SpriteEffects.None, 0f);
            }
            UILinkPointNavigator.SetPosition(6000 + num + blockReplaceIcons + torchGodIcons, vector + rectangle.Size() * 0.15f);
            num++;
        }
        DrawBlockReplacementIcon(0, 0, flag, 0);
        num++;
        if (player.unlockedBiomeTorches)
        {
            DrawTorchBiomeSwapIcon(0, 0, flag, 1);
            num++;
        }
        UILinkPointNavigator.Shortcuts.BUILDERACCCOUNT = num;
    }
 
    private static void GetBuilderAccsCountToShow(Player plr, out int blockReplaceIcons, out int torchGodIcons, out int totalDrawnIcons)
    {
        blockReplaceIcons = 1;
        torchGodIcons = (plr.unlockedBiomeTorches ? 1 : 0);
        totalDrawnIcons = plr.InfoAccMechShowWires.ToInt() * 6 + plr.rulerLine.ToInt() + plr.rulerGrid.ToInt() + plr.autoActuator.ToInt() + plr.autoPaint.ToInt() + blockReplaceIcons + torchGodIcons;
    }
 
    public static void CheckInvasionProgressDisplay()
    {
        if (invasionProgressMode != 2)
        {
            invasionProgressNearInvasion = false;
            return;
        }
        bool flag = false;
        Player player = Main.player[myPlayer];
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle((int)screenPosition.X, (int)screenPosition.Y, screenWidth, screenHeight);
        int num = 5000;
        int num2 = 0;
        for (int i = 0; i < 200; i++)
        {
            if (!npc[i].active)
            {
                continue;
            }
            num2 = 0;
            switch (npc[i].type)
            {
            case 338:
            case 339:
            case 340:
            case 341:
            case 342:
            case 343:
            case 344:
            case 345:
            case 346:
            case 347:
            case 348:
            case 349:
            case 350:
                num2 = 1;
                break;
            case 305:
            case 306:
            case 307:
            case 308:
            case 309:
            case 310:
            case 311:
            case 312:
            case 313:
            case 314:
            case 315:
            case 325:
            case 326:
            case 327:
            case 329:
            case 330:
                num2 = 2;
                break;
            case 26:
            case 27:
            case 28:
            case 29:
            case 111:
                num2 = 4;
                break;
            case 143:
            case 144:
            case 145:
                num2 = 5;
                break;
            case 212:
            case 213:
            case 214:
            case 215:
            case 216:
            case 491:
                num2 = 6;
                break;
            case 381:
            case 382:
            case 383:
            case 385:
            case 386:
            case 388:
            case 389:
            case 390:
            case 391:
            case 395:
                num2 = 7;
                break;
            case 548:
            case 549:
            case 551:
            case 552:
            case 553:
            case 554:
            case 555:
            case 556:
            case 557:
            case 558:
            case 559:
            case 560:
            case 561:
            case 562:
            case 563:
            case 564:
            case 565:
            case 568:
            case 569:
            case 570:
            case 571:
            case 572:
            case 573:
            case 574:
            case 575:
            case 576:
            case 577:
            case 578:
                num2 = 3;
                break;
            }
            if (num2 != 0 && (num2 != 1 || (!((double)player.position.Y > worldSurface * 16.0) && !dayTime && snowMoon)) && (num2 != 2 || (!((double)player.position.Y > worldSurface * 16.0) && !dayTime && pumpkinMoon)) && (num2 != 3 || DD2Event.Ongoing) && (num2 <= 3 || (!((double)player.position.Y > worldSurface * 16.0) && invasionType == num2 - 3)))
            {
                Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle((int)(npc[i].position.X + (float)(npc[i].width / 2)) - num, (int)(npc[i].position.Y + (float)(npc[i].height / 2)) - num, num * 2, num * 2);
                if (rectangle.Intersects(value))
                {
                    flag = true;
                    break;
                }
            }
        }
        invasionProgressNearInvasion = flag;
        if (!flag || invasionProgressIcon != 0)
        {
            return;
        }
        int waveNumber = NPC.waveNumber;
        if (snowMoon)
        {
            int progressMax = NPC.MoonEventRequiredPointsPerWaveLookup[waveNumber];
            ReportInvasionProgress((int)NPC.waveKills, progressMax, 1, waveNumber);
            return;
        }
        if (pumpkinMoon)
        {
            int progressMax2 = NPC.MoonEventRequiredPointsPerWaveLookup[waveNumber];
            ReportInvasionProgress((int)NPC.waveKills, progressMax2, 2, waveNumber);
            return;
        }
        if (DD2Event.Ongoing)
        {
            DD2Event.ReportEventProgress();
            return;
        }
        int progressMax3 = 1;
        if (invasionType != 0 && invasionSizeStart != 0)
        {
            progressMax3 = invasionSizeStart;
        }
        ReportInvasionProgress(invasionSizeStart - invasionSize, progressMax3, num2, 0);
    }
 
    public static void SyncAnInvasion(int toWho)
    {
        int waveNumber = NPC.waveNumber;
        if (snowMoon)
        {
            int num = (new int[21]
            {
                0, 25, 15, 10, 30, 100, 160, 180, 200, 250,
                300, 375, 450, 525, 675, 850, 1025, 1325, 1550, 2000,
                0
            })[waveNumber];
            NetMessage.SendData(78, toWho, -1, null, (int)NPC.waveKills, num, 1f, waveNumber);
        }
        else if (pumpkinMoon)
        {
            int num2 = (new int[16]
            {
                0, 25, 40, 50, 80, 100, 160, 180, 200, 250,
                300, 375, 450, 525, 675, 0
            })[waveNumber];
            NetMessage.SendData(78, toWho, -1, null, (int)NPC.waveKills, num2, 2f, waveNumber);
        }
        else if (DD2Event.Ongoing)
        {
            DD2Event.SyncInvasionProgress(toWho);
        }
        else if (invasionType > 0)
        {
            int num3 = 1;
            if (invasionType != 0 && invasionSizeStart != 0)
            {
                num3 = invasionSizeStart;
            }
            NetMessage.SendData(78, toWho, -1, null, invasionSizeStart - invasionSize, num3, invasionType + 3);
        }
    }
 
    public static void ReportInvasionProgress(int progress, int progressMax, int icon, int progressWave)
    {
        invasionProgress = progress;
        invasionProgressMax = progressMax;
        invasionProgressIcon = icon;
        invasionProgressWave = progressWave;
        invasionProgressDisplayLeft = 160;
    }
 
    public static void DrawInvasionProgress()
    {
        if (invasionProgress == -1)
        {
            return;
        }
        if (invasionProgressMode == 2 && invasionProgressNearInvasion && invasionProgressDisplayLeft < 160)
        {
            invasionProgressDisplayLeft = 160;
        }
        if (!gamePaused && invasionProgressDisplayLeft > 0)
        {
            invasionProgressDisplayLeft--;
        }
        if (invasionProgressDisplayLeft > 0)
        {
            invasionProgressAlpha += 0.05f;
        }
        else
        {
            invasionProgressAlpha -= 0.05f;
        }
        if (invasionProgressMode == 0)
        {
            invasionProgressDisplayLeft = 0;
            invasionProgressAlpha = 0f;
        }
        if (invasionProgressAlpha < 0f)
        {
            invasionProgressAlpha = 0f;
        }
        if (invasionProgressAlpha > 1f)
        {
            invasionProgressAlpha = 1f;
        }
        if (invasionProgressAlpha <= 0f)
        {
            return;
        }
        float num = 0.5f + invasionProgressAlpha * 0.5f;
        Texture2D value = TextureAssets.Extra[9].Value;
        string text = "";
        Microsoft.Xna.Framework.Color c = Microsoft.Xna.Framework.Color.White;
        if (invasionProgressIcon == 1)
        {
            value = TextureAssets.Extra[8].Value;
            text = Lang.inter[83].Value;
            c = new Microsoft.Xna.Framework.Color(64, 109, 164) * 0.5f;
        }
        else if (invasionProgressIcon == 2)
        {
            value = TextureAssets.Extra[12].Value;
            text = Lang.inter[84].Value;
            c = new Microsoft.Xna.Framework.Color(112, 86, 114) * 0.5f;
        }
        else if (invasionProgressIcon == 3)
        {
            value = TextureAssets.Extra[79].Value;
            text = Language.GetTextValue("DungeonDefenders2.InvasionProgressTitle");
            c = new Microsoft.Xna.Framework.Color(88, 0, 160) * 0.5f;
        }
        else if (invasionProgressIcon == 7)
        {
            value = TextureAssets.Extra[10].Value;
            text = Lang.inter[85].Value;
            c = new Microsoft.Xna.Framework.Color(165, 160, 155) * 0.5f;
        }
        else if (invasionProgressIcon == 6)
        {
            value = TextureAssets.Extra[11].Value;
            text = Lang.inter[86].Value;
            c = new Microsoft.Xna.Framework.Color(148, 122, 72) * 0.5f;
        }
        else if (invasionProgressIcon == 5)
        {
            value = TextureAssets.Extra[7].Value;
            text = Lang.inter[87].Value;
            c = new Microsoft.Xna.Framework.Color(173, 135, 140) * 0.5f;
        }
        else if (invasionProgressIcon == 4)
        {
            value = TextureAssets.Extra[9].Value;
            text = Lang.inter[88].Value;
            c = new Microsoft.Xna.Framework.Color(94, 72, 131) * 0.5f;
        }
        if (invasionProgressWave > 0)
        {
            int num2 = (int)(200f * num);
            int num3 = (int)(45f * num);
            Vector2 vector = new Vector2(screenWidth - 120, screenHeight - 40);
            Utils.DrawInvBG(R: new Microsoft.Xna.Framework.Rectangle((int)vector.X - num2 / 2, (int)vector.Y - num3 / 2, num2, num3), sb: spriteBatch, c: new Microsoft.Xna.Framework.Color(63, 65, 151, 255) * 0.785f);
            string text2 = "";
            text2 = Language.GetTextValue(arg1: (invasionProgressMax != 0) ? ((int)((float)invasionProgress * 100f / (float)invasionProgressMax) + "%") : Language.GetTextValue("Game.InvasionPoints", invasionProgress), key: "Game.WaveMessage", arg0: invasionProgressWave);
            Texture2D value2 = TextureAssets.ColorBar.Value;
            _ = TextureAssets.ColorBlip.Value;
            float num4 = MathHelper.Clamp((float)invasionProgress / (float)invasionProgressMax, 0f, 1f);
            if (invasionProgressMax == 0)
            {
                num4 = 1f;
            }
            float num5 = 169f * num;
            float num6 = 8f * num;
            Vector2 vector2 = vector + Vector2.UnitY * num6 + Vector2.UnitX * 1f;
            Utils.DrawBorderString(spriteBatch, text2, vector2, Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, num, 0.5f, 1f);
            spriteBatch.Draw(value2, vector, null, Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, 0f, new Vector2(value2.Width / 2, 0f), num, SpriteEffects.None, 0f);
            vector2 += Vector2.UnitX * (num4 - 0.5f) * num5;
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector2, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), new Microsoft.Xna.Framework.Color(255, 241, 51) * invasionProgressAlpha, 0f, new Vector2(1f, 0.5f), new Vector2(num5 * num4, num6), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector2, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), new Microsoft.Xna.Framework.Color(255, 165, 0, 127) * invasionProgressAlpha, 0f, new Vector2(1f, 0.5f), new Vector2(2f, num6), SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector2, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), Microsoft.Xna.Framework.Color.Black * invasionProgressAlpha, 0f, new Vector2(0f, 0.5f), new Vector2(num5 * (1f - num4), num6), SpriteEffects.None, 0f);
        }
        else
        {
            int num7 = (int)(200f * num);
            int num8 = (int)(45f * num);
            Vector2 vector3 = new Vector2(screenWidth - 120, screenHeight - 40);
            Utils.DrawInvBG(R: new Microsoft.Xna.Framework.Rectangle((int)vector3.X - num7 / 2, (int)vector3.Y - num8 / 2, num7, num8), sb: spriteBatch, c: new Microsoft.Xna.Framework.Color(63, 65, 151, 255) * 0.785f);
            string text3 = "";
            text3 = ((invasionProgressMax != 0) ? ((int)((float)invasionProgress * 100f / (float)invasionProgressMax) + "%") : invasionProgress.ToString());
            text3 = Language.GetTextValue("Game.WaveCleared", text3);
            Texture2D value3 = TextureAssets.ColorBar.Value;
            _ = TextureAssets.ColorBlip.Value;
            if (invasionProgressMax != 0)
            {
                spriteBatch.Draw(value3, vector3, null, Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, 0f, new Vector2(value3.Width / 2, 0f), num, SpriteEffects.None, 0f);
                float num9 = MathHelper.Clamp((float)invasionProgress / (float)invasionProgressMax, 0f, 1f);
                Vector2 vector4 = FontAssets.MouseText.Value.MeasureString(text3);
                float num10 = num;
                if (vector4.Y > 22f)
                {
                    num10 *= 22f / vector4.Y;
                }
                float num11 = 169f * num;
                float num12 = 8f * num;
                Vector2 vector5 = vector3 + Vector2.UnitY * num12 + Vector2.UnitX * 1f;
                Utils.DrawBorderString(spriteBatch, text3, vector5 + new Vector2(0f, -4f), Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, num10, 0.5f, 1f);
                vector5 += Vector2.UnitX * (num9 - 0.5f) * num11;
                spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector5, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), new Microsoft.Xna.Framework.Color(255, 241, 51) * invasionProgressAlpha, 0f, new Vector2(1f, 0.5f), new Vector2(num11 * num9, num12), SpriteEffects.None, 0f);
                spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector5, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), new Microsoft.Xna.Framework.Color(255, 165, 0, 127) * invasionProgressAlpha, 0f, new Vector2(1f, 0.5f), new Vector2(2f, num12), SpriteEffects.None, 0f);
                spriteBatch.Draw(TextureAssets.MagicPixel.Value, vector5, new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), Microsoft.Xna.Framework.Color.Black * invasionProgressAlpha, 0f, new Vector2(0f, 0.5f), new Vector2(num11 * (1f - num9), num12), SpriteEffects.None, 0f);
            }
        }
        Vector2 vector6 = FontAssets.MouseText.Value.MeasureString(text);
        float num13 = 120f;
        if (vector6.X > 200f)
        {
            num13 += vector6.X - 200f;
        }
        Microsoft.Xna.Framework.Rectangle r3 = Utils.CenteredRectangle(new Vector2((float)screenWidth - num13, screenHeight - 80), (vector6 + new Vector2(value.Width + 12, 6f)) * num);
        Utils.DrawInvBG(spriteBatch, r3, c);
        spriteBatch.Draw(value, r3.Left() + Vector2.UnitX * num * 8f, null, Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, 0f, new Vector2(0f, value.Height / 2), num * 0.8f, SpriteEffects.None, 0f);
        Utils.DrawBorderString(spriteBatch, text, r3.Right() + Vector2.UnitX * num * -22f, Microsoft.Xna.Framework.Color.White * invasionProgressAlpha, num * 0.9f, 1f, 0.4f);
    }
 
    protected void QuitGame()
    {
        SaveSettings();
        if (!dedServ)
        {
            SocialAPI.Shutdown();
        }
        Assets.TransferCompletedAssets();
        Exit();
    }
 
    private void Main_Exiting(object sender, EventArgs e)
    {
        TryDisposingEverything();
    }
 
    private static void TryDisposingEverything()
    {
        ChromaInitializer.DisableAllDeviceGroups();
        CaptureManager.Instance.Dispose();
        audioSystem.Dispose();
    }
 
    protected Microsoft.Xna.Framework.Color randColor()
    {
        int num = 0;
        int num2 = 0;
        int num3 = 0;
        while (num + num3 + num2 <= 150)
        {
            num = rand.Next(256);
            num2 = rand.Next(256);
            num3 = rand.Next(256);
        }
        return new Microsoft.Xna.Framework.Color(num, num2, num3, 255);
    }
 
    public static Microsoft.Xna.Framework.Color hslToRgb(Vector3 hslVector)
    {
        return hslToRgb(hslVector.X, hslVector.Y, hslVector.Z);
    }
 
    public static Microsoft.Xna.Framework.Color hslToRgb(float Hue, float Saturation, float Luminosity, byte a = byte.MaxValue)
    {
        byte r;
        byte g;
        byte b;
        if (Saturation == 0f)
        {
            r = (byte)Math.Round((double)Luminosity * 255.0);
            g = (byte)Math.Round((double)Luminosity * 255.0);
            b = (byte)Math.Round((double)Luminosity * 255.0);
        }
        else
        {
            double num = Hue;
            double num2 = ((!((double)Luminosity < 0.5)) ? ((double)(Luminosity + Saturation - Luminosity * Saturation)) : ((double)Luminosity * (1.0 + (double)Saturation)));
            double t = 2.0 * (double)Luminosity - num2;
            double c = num + 1.0 / 3.0;
            double c2 = num;
            double c3 = num - 1.0 / 3.0;
            c = hue2rgb(c, t, num2);
            c2 = hue2rgb(c2, t, num2);
            double num3 = hue2rgb(c3, t, num2);
            r = (byte)Math.Round(c * 255.0);
            g = (byte)Math.Round(c2 * 255.0);
            b = (byte)Math.Round(num3 * 255.0);
        }
        return new Microsoft.Xna.Framework.Color(r, g, b, a);
    }
 
    public static double hue2rgb(double c, double t1, double t2)
    {
        if (c < 0.0)
        {
            c += 1.0;
        }
        if (c > 1.0)
        {
            c -= 1.0;
        }
        if (6.0 * c < 1.0)
        {
            return t1 + (t2 - t1) * 6.0 * c;
        }
        if (2.0 * c < 1.0)
        {
            return t2;
        }
        if (3.0 * c < 2.0)
        {
            return t1 + (t2 - t1) * (2.0 / 3.0 - c) * 6.0;
        }
        return t1;
    }
 
    public static Vector3 rgbToHsl(Microsoft.Xna.Framework.Color newColor)
    {
        float num = (int)newColor.R;
        float num2 = (int)newColor.G;
        float num3 = (int)newColor.B;
        num /= 255f;
        num2 /= 255f;
        num3 /= 255f;
        float val = Math.Max(num, num2);
        val = Math.Max(val, num3);
        float val2 = Math.Min(num, num2);
        val2 = Math.Min(val2, num3);
        float num4 = 0f;
        float num5 = (val + val2) / 2f;
        float y;
        if (val == val2)
        {
            num4 = (y = 0f);
        }
        else
        {
            float num6 = val - val2;
            y = (((double)num5 > 0.5) ? (num6 / (2f - val - val2)) : (num6 / (val + val2)));
            if (val == num)
            {
                num4 = (num2 - num3) / num6 + (float)((num2 < num3) ? 6 : 0);
            }
            if (val == num2)
            {
                num4 = (num3 - num) / num6 + 2f;
            }
            if (val == num3)
            {
                num4 = (num - num2) / num6 + 4f;
            }
            num4 /= 6f;
        }
        return new Vector3(num4, y, num5);
    }
 
    public static void DrawCursor(Vector2 bonus, bool smart = false)
    {
        if (gameMenu && alreadyGrabbingSunOrMoon)
        {
            return;
        }
        if (player[myPlayer].dead || player[myPlayer].mouseInterface)
        {
            ClearSmartInteract();
            TileInteractionLX = (TileInteractionHX = (TileInteractionLY = (TileInteractionHY = -1)));
        }
        Microsoft.Xna.Framework.Color color = cursorColor;
        if (!gameMenu && LocalPlayer.hasRainbowCursor)
        {
            color = hslToRgb(GlobalTimeWrappedHourly * 0.25f % 1f, 1f, 0.5f);
        }
        bool flag = UILinkPointNavigator.Available && !PlayerInput.InBuildingMode;
        if (PlayerInput.SettingsForUI.ShowGamepadCursor)
        {
            if ((player[myPlayer].dead && !player[myPlayer].ghost && !gameMenu) || PlayerInput.InvisibleGamepadInMenus)
            {
                return;
            }
            Vector2 t = new Vector2(mouseX, mouseY);
            Vector2 t2 = Vector2.Zero;
            bool flag2 = SmartCursorIsUsed;
            if (flag2)
            {
                PlayerInput.smartSelectPointer.UpdateCenter(ScreenSize.ToVector2() / 2f);
                t2 = PlayerInput.smartSelectPointer.GetPointerPosition();
                if (Vector2.Distance(t2, t) < 1f)
                {
                    flag2 = false;
                }
                else
                {
                    Utils.Swap(ref t, ref t2);
                }
            }
            float num = 1f;
            if (flag2)
            {
                num = 0.3f;
                color = Microsoft.Xna.Framework.Color.White * GamepadCursorAlpha;
                int num2 = 17;
                int frameX = 0;
                spriteBatch.Draw(TextureAssets.Cursors[num2].Value, t2 + bonus, TextureAssets.Cursors[num2].Frame(1, 1, frameX), color, (float)Math.PI / 2f * GlobalTimeWrappedHourly, TextureAssets.Cursors[num2].Frame(1, 1, frameX).Size() / 2f, cursorScale, SpriteEffects.None, 0f);
            }
            if (smart && !flag)
            {
                color = Microsoft.Xna.Framework.Color.White * GamepadCursorAlpha * num;
                int num3 = 13;
                int frameX2 = 0;
                spriteBatch.Draw(TextureAssets.Cursors[num3].Value, t + bonus, TextureAssets.Cursors[num3].Frame(2, 1, frameX2), color, 0f, TextureAssets.Cursors[num3].Frame(2, 1, frameX2).Size() / 2f, cursorScale, SpriteEffects.None, 0f);
            }
            else
            {
                color = Microsoft.Xna.Framework.Color.White;
                int num4 = 15;
                spriteBatch.Draw(TextureAssets.Cursors[num4].Value, new Vector2(mouseX, mouseY) + bonus, null, color, 0f, TextureAssets.Cursors[num4].Value.Size() / 2f, cursorScale, SpriteEffects.None, 0f);
            }
        }
        else
        {
            int num5 = smart.ToInt();
            spriteBatch.Draw(TextureAssets.Cursors[num5].Value, new Vector2(mouseX, mouseY) + bonus + Vector2.One, null, new Microsoft.Xna.Framework.Color((int)((float)(int)color.R * 0.2f), (int)((float)(int)color.G * 0.2f), (int)((float)(int)color.B * 0.2f), (int)((float)(int)color.A * 0.5f)), 0f, default(Vector2), cursorScale * 1.1f, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.Cursors[num5].Value, new Vector2(mouseX, mouseY) + bonus, null, color, 0f, default(Vector2), cursorScale, SpriteEffects.None, 0f);
        }
    }
 
    public static void ClearSmartInteract()
    {
        SmartInteractShowingGenuine = false;
        SmartInteractShowingFake = false;
        SmartInteractNPC = -1;
        SmartInteractProj = -1;
        SmartInteractTileCoords.Clear();
        SmartInteractTileCoordsSelected.Clear();
    }
 
    public static Vector2 DrawThickCursor(bool smart = false)
    {
        if (ThickMouse)
        {
            bool showGamepadCursor = PlayerInput.SettingsForUI.ShowGamepadCursor;
            if (gameMenu && alreadyGrabbingSunOrMoon)
            {
                return Vector2.Zero;
            }
            if (showGamepadCursor && PlayerInput.InvisibleGamepadInMenus)
            {
                return Vector2.Zero;
            }
            if (showGamepadCursor && player[myPlayer].dead && !player[myPlayer].ghost && !gameMenu)
            {
                return Vector2.Zero;
            }
            bool flag = UILinkPointNavigator.Available && !PlayerInput.InBuildingMode;
            Microsoft.Xna.Framework.Color mouseBorderColor = MouseBorderColor;
            int num = 11;
            num += smart.ToInt();
            for (int i = 0; i < 4; i++)
            {
                Vector2 vector = Vector2.Zero;
                switch (i)
                {
                case 0:
                    vector = new Vector2(0f, 1f);
                    break;
                case 1:
                    vector = new Vector2(1f, 0f);
                    break;
                case 2:
                    vector = new Vector2(0f, -1f);
                    break;
                case 3:
                    vector = new Vector2(-1f, 0f);
                    break;
                }
                vector *= 1f;
                vector += Vector2.One * 2f;
                Vector2 origin = new Vector2(2f);
                Microsoft.Xna.Framework.Rectangle? sourceRectangle = null;
                float scale = cursorScale * 1.1f;
                if (showGamepadCursor)
                {
                    if (smart && !flag)
                    {
                        num = 13;
                        int frameX = 0;
                        vector = Vector2.One;
                        sourceRectangle = TextureAssets.Cursors[num].Frame(2, 1, frameX);
                        origin = TextureAssets.Cursors[num].Frame(2, 1, frameX).Size() / 2f;
                        mouseBorderColor *= GamepadCursorAlpha;
                    }
                    else
                    {
                        num = 15;
                        vector = Vector2.One;
                        origin = TextureAssets.Cursors[num].Value.Size() / 2f;
                    }
                }
                spriteBatch.Draw(TextureAssets.Cursors[num].Value, new Vector2(mouseX, mouseY) + vector, sourceRectangle, mouseBorderColor, 0f, origin, scale, SpriteEffects.None, 0f);
            }
            return new Vector2(2f);
        }
        return Vector2.Zero;
    }
 
    private void OnCharacterNamed(string text)
    {
        PendingPlayer.name = text.Trim();
        PlayerFileData.CreateAndSave(PendingPlayer);
        LoadPlayers();
        menuMode = 1;
    }
 
    private void OnSeedSelected(string text)
    {
        text = text.Trim();
        if (text.Length == 0)
        {
            ActiveWorldFileData.SetSeedToRandom();
        }
        else
        {
            ActiveWorldFileData.SetSeed(text);
        }
        menuMode = 10;
        WorldGen.CreateNewWorld();
    }
 
    private void OnWorldNamed(string text)
    {
        menuMode = 10;
        worldName = text.Trim();
        ActiveWorldFileData = WorldFile.CreateMetadata(worldName, SocialAPI.Cloud != null && SocialAPI.Cloud.EnabledByDefault, GameMode);
        menuMode = 5000;
    }
 
    private static Action CreateGoToMenuEvent(int menu)
    {
        return delegate
        {
            menuMode = menu;
            UILinkPointNavigator.Shortcuts.FANCYUI_SPECIAL_INSTRUCTIONS = 0;
        };
    }
 
    public static void GoToWorldSelect()
    {
        menuMode = 888;
        MenuUI.SetState(_worldSelectMenu);
    }
 
    public static void StartClientGameplay()
    {
        menuMode = 10;
        Netplay.StartTcpClient();
    }
 
    public static void ReleaseHostAndPlayProcess()
    {
        if (tServer != null)
        {
            tServer = null;
        }
    }
 
    private string SanitizePathArgument(string argumentName, string argumentPath)
    {
        string input = Regex.Replace(argumentPath, "(\\\\*)\"", "$1$1\\\"");
        string text = "\"" + Regex.Replace(input, "(\\\\+)$", "$1$1") + "\"";
        return " -" + argumentName + " " + text;
    }
 
    protected void DrawMenu(GameTime gameTime)
    {
        if (!IsEngineLoaded)
        {
            IsEngineLoaded = true;
            if (Main.OnEngineLoad != null)
            {
                Main.OnEngineLoad();
            }
        }
        GamepadMainMenuHandler.Update();
        GamepadMainMenuHandler.MenuItemPositions.Clear();
        int num = menuMode;
        if (menuMode <= 1 && slimeRain)
        {
            StopSlimeRain();
        }
        render = false;
        SceneMetrics.Reset();
        drawingPlayerChat = false;
        chatMonitor.Clear();
        screenLastPosition = screenPosition;
        screenPosition.Y = (float)(worldSurface * 16.0 - (double)screenHeight);
        MenuXMovement = 4f;
        if (alreadyGrabbingSunOrMoon)
        {
            playOldTile = true;
            if (starGame)
            {
                playOldTile = false;
            }
        }
        screenPosition.X += MenuXMovement;
        if (screenPosition.X > 2.1474835E+09f)
        {
            screenPosition.X = 0f;
        }
        if (screenPosition.X < -2.1474835E+09f)
        {
            screenPosition.X = 0f;
        }
        Star.UpdateStars();
        Cloud.UpdateClouds();
        DrawFPS();
        background = 0;
        byte b = (byte)((255 + tileColor.R * 2) / 3);
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(b, b, b, 255);
        if (WorldGen.remixWorldGen)
        {
            logoRotation += logoRotationSpeed * 4E-05f;
            if ((double)logoRotation < 3.04)
            {
                logoRotation += logoRotationSpeed * 0.0016f;
                if (logoRotationSpeed < 0f)
                {
                    logoRotationSpeed = 0f;
                }
            }
            if ((double)logoRotation > 3.22)
            {
                logoRotationDirection = -1f;
            }
            else if ((double)logoRotation < 3.06)
            {
                logoRotationDirection = 1f;
            }
            if (logoRotationSpeed < 20f && logoRotationDirection == 1f)
            {
                logoRotationSpeed += 1f;
            }
            else if (logoRotationSpeed > -20f && logoRotationDirection == -1f)
            {
                logoRotationSpeed -= 1f;
            }
            logoScale += logoScaleSpeed * 9E-05f;
            if (logoScale > 1f)
            {
                logoScaleDirection = -1f;
            }
            else if (logoScale < 0.9f)
            {
                logoScaleDirection = 1f;
            }
            if (logoScaleSpeed < 50f && logoScaleDirection == 1f)
            {
                logoScaleSpeed += 1f;
            }
            else if (logoScaleSpeed > -50f && logoScaleDirection == -1f)
            {
                logoScaleSpeed -= 1f;
            }
        }
        else if (WorldGen.drunkWorldGen)
        {
            logoRotation += logoRotationSpeed * 4E-06f;
            if (logoRotationSpeed > 0f)
            {
                logoRotationSpeed += 1500f;
            }
            else
            {
                logoRotationSpeed -= 1500f;
            }
            logoScale -= 0.05f;
            if (logoScale < 0f)
            {
                logoScale = 0f;
            }
        }
        else
        {
            if ((double)logoRotation > 0.09)
            {
                logoRotation += logoRotationSpeed * 0.0016f;
                if (logoRotationSpeed > 0f)
                {
                    logoRotationSpeed = 0f;
                }
            }
            logoRotation += logoRotationSpeed * 4E-06f;
            if ((double)logoRotation > 0.08)
            {
                logoRotationDirection = -1f;
            }
            else if ((double)logoRotation < -0.08)
            {
                logoRotationDirection = 1f;
            }
            if (logoRotationSpeed < 20f && logoRotationDirection == 1f)
            {
                logoRotationSpeed += 1f;
            }
            else if (logoRotationSpeed > -20f && logoRotationDirection == -1f)
            {
                logoRotationSpeed -= 1f;
            }
            logoScale += logoScaleSpeed * 9E-06f;
            if ((double)logoScale > 1.35)
            {
                logoScaleDirection = -1f;
            }
            else if (logoScale < 1f)
            {
                logoScaleDirection = 1f;
            }
            if (logoScaleSpeed < 50f && logoScaleDirection == 1f)
            {
                logoScaleSpeed += 1f;
            }
            else if (logoScaleSpeed > -50f && logoScaleDirection == -1f)
            {
                logoScaleSpeed -= 1f;
            }
        }
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color((byte)((float)(int)color.R * ((float)LogoA / 255f)), (byte)((float)(int)color.G * ((float)LogoA / 255f)), (byte)((float)(int)color.B * ((float)LogoA / 255f)), (byte)((float)(int)color.A * ((float)LogoA / 255f)));
        Microsoft.Xna.Framework.Color color3 = new Microsoft.Xna.Framework.Color((byte)((float)(int)color.R * ((float)LogoB / 255f)), (byte)((float)(int)color.G * ((float)LogoB / 255f)), (byte)((float)(int)color.B * ((float)LogoB / 255f)), (byte)((float)(int)color.A * ((float)LogoB / 255f)));
        if (playOldTile)
        {
            spriteBatch.Draw(TextureAssets.Logo3.Value, new Vector2(screenWidth / 2, 100f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Logo.Width(), TextureAssets.Logo.Height()), color2, logoRotation, new Vector2(TextureAssets.Logo.Width() / 2, TextureAssets.Logo.Height() / 2), logoScale, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.Logo4.Value, new Vector2(screenWidth / 2, 100f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Logo.Width(), TextureAssets.Logo.Height()), color3, logoRotation, new Vector2(TextureAssets.Logo.Width() / 2, TextureAssets.Logo.Height() / 2), logoScale, SpriteEffects.None, 0f);
        }
        else
        {
            spriteBatch.Draw(TextureAssets.Logo.Value, new Vector2(screenWidth / 2, 100f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Logo.Width(), TextureAssets.Logo.Height()), color2, logoRotation, new Vector2(TextureAssets.Logo.Width() / 2, TextureAssets.Logo.Height() / 2), logoScale, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.Logo2.Value, new Vector2(screenWidth / 2, 100f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Logo.Width(), TextureAssets.Logo.Height()), color3, logoRotation, new Vector2(TextureAssets.Logo.Width() / 2, TextureAssets.Logo.Height() / 2), logoScale, SpriteEffects.None, 0f);
        }
        if (dayTime && !WorldGen.remixWorldGen)
        {
            LogoA += 2;
            if (LogoA > 255)
            {
                LogoA = 255;
            }
            LogoB--;
            if (LogoB < 0)
            {
                LogoB = 0;
            }
        }
        else
        {
            LogoB += 2;
            if (LogoB > 255)
            {
                LogoB = 255;
            }
            LogoA--;
            if (LogoA < 0)
            {
                LogoA = 0;
                LogoT = true;
            }
        }
        int num2 = 250;
        int num3 = screenWidth / 2;
        int num4 = 80;
        int num5 = 0;
        int num6 = menuMode;
        int num7 = 0;
        int num8 = 0;
        bool flag = false;
        bool flag2 = false;
        bool flag3 = false;
        int num9 = 0;
        bool[] array = new bool[maxMenuItems];
        bool[] array2 = new bool[maxMenuItems];
        bool[] array3 = new bool[maxMenuItems];
        int[] array4 = new int[maxMenuItems];
        int[] array5 = new int[maxMenuItems];
        byte[] array6 = new byte[maxMenuItems];
        float[] array7 = new float[maxMenuItems];
        bool[] array8 = new bool[maxMenuItems];
        bool flag4 = false;
        bool flag5 = UILinkPointNavigator.Shortcuts.BackButtonInUse && !UILinkPointNavigator.Shortcuts.BackButtonLock;
        for (int i = 0; i < maxMenuItems; i++)
        {
            array[i] = false;
            array2[i] = false;
            array4[i] = 0;
            array5[i] = 0;
            array7[i] = 1f;
        }
        string[] array9 = new string[maxMenuItems];
        if (menuMode == -1)
        {
            menuMode = 0;
        }
        if (Program.LoadedEverything)
        {
            GamepadMainMenuHandler.CanRun = true;
        }
        if (menuMode == 1212)
        {
            array9[0] = Lang.menu[102].Value;
            num4 = 50;
            num2 = 200;
            num4 = 33;
            num2 = 200;
            array4[0] = -20;
            array4[1] = 25;
            array4[2] = 25;
            array4[3] = 25;
            array4[4] = 25;
            array4[5] = 25;
            array4[6] = 25;
            array4[7] = 25;
            array4[8] = 25;
            array4[9] = 25;
            array[0] = true;
            array9[1] = Language.GetTextValue("Language.English");
            array9[2] = Language.GetTextValue("Language.German");
            array9[3] = Language.GetTextValue("Language.Italian");
            array9[4] = Language.GetTextValue("Language.French");
            array9[5] = Language.GetTextValue("Language.Spanish");
            array9[6] = Language.GetTextValue("Language.Russian");
            array9[7] = Language.GetTextValue("Language.Chinese");
            array9[8] = Language.GetTextValue("Language.Portuguese");
            array9[9] = Language.GetTextValue("Language.Polish");
            num5 = 10;
            for (int j = 0; j < num5; j++)
            {
                array7[j] = 0.75f;
            }
            array7[0] = 1f;
            if (selectedMenu >= 1)
            {
                changeTheTitle = true;
                LanguageManager.Instance.SetLanguage(selectedMenu);
                menuMode = 0;
                SoundEngine.PlaySound(10);
                SaveSettings();
            }
        }
        else if (menuMode == 1213)
        {
            array9[0] = Lang.menu[102].Value;
            array[0] = true;
            array9[1] = Language.GetTextValue("Language.English");
            array9[2] = Language.GetTextValue("Language.German");
            array9[3] = Language.GetTextValue("Language.Italian");
            array9[4] = Language.GetTextValue("Language.French");
            array9[5] = Language.GetTextValue("Language.Spanish");
            array9[6] = Language.GetTextValue("Language.Russian");
            array9[7] = Language.GetTextValue("Language.Chinese");
            array9[8] = Language.GetTextValue("Language.Portuguese");
            array9[9] = Language.GetTextValue("Language.Polish");
            array9[10] = Lang.menu[5].Value;
            num5 = 11;
            if (selectedMenu == 10 || flag5)
            {
                flag5 = false;
                menuMode = 11;
                SoundEngine.PlaySound(11);
            }
            else if (selectedMenu >= 1)
            {
                changeTheTitle = true;
                LanguageManager.Instance.SetLanguage(selectedMenu);
                SoundEngine.PlaySound(12);
                SaveSettings();
            }
            num4 = 33;
            num2 = 200;
            array4[0] = -20;
            array4[10] = 10;
            for (int k = 0; k < num5; k++)
            {
                array7[k] = 0.75f;
            }
            array7[0] = 0.85f;
            array7[10] = 0.95f;
        }
        else if (netMode == 2)
        {
            bool flag6 = true;
            for (int l = 0; l < 8; l++)
            {
                if (l >= 255)
                {
                    continue;
                }
                try
                {
                    array9[l] = Netplay.Clients[l].StatusText;
                    if (Netplay.Clients[l].IsActive && showSpam)
                    {
                        ref string reference = ref array9[l];
                        reference = reference + " (" + NetMessage.buffer[l].spamCount + ")";
                    }
                }
                catch
                {
                    array9[l] = "";
                }
                array[l] = true;
                if (array9[l] != "" && array9[l] != null)
                {
                    flag6 = false;
                }
            }
            if (flag6)
            {
                array9[0] = Lang.menu[0].Value;
                array9[1] = Lang.menu[1].Value + Netplay.ListenPort + ".";
            }
            num5 = 11;
            array9[9] = statusText;
            array[9] = true;
            num2 = 170;
            num4 = 30;
            array4[10] = 20;
            array4[10] = 40;
            array9[10] = Lang.menu[2].Value;
            if (selectedMenu == 10 || flag5)
            {
                flag5 = false;
                Netplay.Disconnect = true;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 31)
        {
            if (PlayerInput.SettingsForUI.ShowGamepadHints)
            {
                UIVirtualKeyboard uIVirtualKeyboard = new UIVirtualKeyboard(Lang.menu[3].Value, Netplay.ServerPassword, OnSubmitServerPasswordFromRequest, CanceledGivingServerPassword, 0, allowEmpty: true);
                uIVirtualKeyboard.HideContents = HidePassword;
                UserInterface.ActiveInstance.SetState(uIVirtualKeyboard);
                menuMode = 888;
            }
            string serverPassword = Netplay.ServerPassword;
            PlayerInput.WritingText = true;
            instance.HandleIME();
            Netplay.ServerPassword = GetInputText(Netplay.ServerPassword);
            if (serverPassword != Netplay.ServerPassword)
            {
                SoundEngine.PlaySound(12);
            }
            array9[0] = Lang.menu[3].Value;
            textBlinkerCount++;
            if (textBlinkerCount >= 20)
            {
                if (textBlinkerState == 0)
                {
                    textBlinkerState = 1;
                }
                else
                {
                    textBlinkerState = 0;
                }
                textBlinkerCount = 0;
            }
            array9[1] = Netplay.ServerPassword;
            if (HidePassword)
            {
                array9[1] = "";
                for (int m = 0; m < Netplay.ServerPassword.Length; m++)
                {
                    array9[1] += "*";
                }
            }
            if (textBlinkerState == 1)
            {
                array9[1] += "|";
                array5[1] = 1;
            }
            else
            {
                array9[1] += " ";
            }
            array[0] = true;
            array[1] = true;
            array4[1] = -20;
            array4[2] = 20;
            array9[2] = Lang.menu[4].Value;
            array9[3] = Lang.menu[5].Value;
            num5 = 4;
            if (selectedMenu == 3 || flag5)
            {
                flag5 = false;
                CanceledGivingServerPassword();
            }
            else if (selectedMenu == 2 || inputTextEnter)
            {
                OnSubmitServerPasswordFromRequest();
            }
        }
        else if ((netMode == 1 && menuMode != 888) || menuMode == 14)
        {
            num5 = 2;
            array9[0] = statusText;
            array[0] = true;
            num2 = 300;
            int num10 = statusText.Split('\n').Length - 1;
            array7[0] = 1f - (float)num10 * 0.04f;
            array4[0] = num10 * -18;
            array4[1] = num10 * 28;
            array9[1] = Lang.menu[6].Value;
            gameTips.Update();
            gameTips.Draw();
            if (selectedMenu == 1 || flag5)
            {
                flag5 = false;
                Netplay.InvalidateAllOngoingIPSetAttempts();
                Netplay.Disconnect = true;
                Netplay.Connection.Socket.Close();
                SoundEngine.PlaySound(11);
                menuMode = 0;
                netMode = 0;
                if (tServer != null)
                {
                    try
                    {
                        tServer.Kill();
                        tServer = null;
                    }
                    catch
                    {
                    }
                }
            }
        }
        else if (menuMode == 882)
        {
            num5 = 2;
            array[0] = true;
            num2 = 300;
            array9[0] = statusText;
            array9[1] = Lang.menu[6].Value;
            if (selectedMenu == 1 || flag5)
            {
                flag5 = false;
                SoundEngine.PlaySound(11);
                menuMode = 0;
                netMode = 0;
                if (SocialAPI.Network != null)
                {
                    SocialAPI.Network.CancelJoin();
                }
            }
        }
        else if (menuMode == 30)
        {
            if (PlayerInput.SettingsForUI.ShowGamepadHints)
            {
                UIVirtualKeyboard uIVirtualKeyboard2 = new UIVirtualKeyboard(Lang.menu[7].Value, Netplay.ServerPassword, OnSubmitServerPassword, ExitServerPasswordMenu, 0, allowEmpty: true);
                uIVirtualKeyboard2.HideContents = HidePassword;
                UserInterface.ActiveInstance.SetState(uIVirtualKeyboard2);
                menuMode = 888;
            }
            string serverPassword2 = Netplay.ServerPassword;
            PlayerInput.WritingText = true;
            instance.HandleIME();
            Netplay.ServerPassword = GetInputText(Netplay.ServerPassword);
            if (serverPassword2 != Netplay.ServerPassword)
            {
                SoundEngine.PlaySound(12);
            }
            array9[0] = Lang.menu[7].Value;
            textBlinkerCount++;
            if (textBlinkerCount >= 20)
            {
                if (textBlinkerState == 0)
                {
                    textBlinkerState = 1;
                }
                else
                {
                    textBlinkerState = 0;
                }
                textBlinkerCount = 0;
            }
            array9[1] = Netplay.ServerPassword;
            if (HidePassword)
            {
                array9[1] = "";
                for (int n = 0; n < Netplay.ServerPassword.Length; n++)
                {
                    array9[1] += "*";
                }
            }
            if (textBlinkerState == 1)
            {
                array9[1] += "|";
                array5[1] = 1;
            }
            else
            {
                array9[1] += " ";
            }
            array[0] = true;
            array[1] = true;
            array4[1] = -20;
            array4[2] = 20;
            array9[2] = Lang.menu[4].Value;
            array9[3] = Lang.menu[5].Value;
            num5 = 4;
            if (selectedMenu == 3 || flag5)
            {
                flag5 = false;
                ExitServerPasswordMenu();
            }
            else if (selectedMenu == 2 || inputTextEnter || autoPass)
            {
                OnSubmitServerPassword();
            }
        }
        else if (menuMode == 889)
        {
            num2 = 200;
            num4 = 60;
            array4[1] = 30;
            array4[2] = 30;
            array4[3] = 30;
            array4[4] = 70;
            array4[5] = 70;
            num5 = 6;
            array9[0] = Lang.menu[135].Value;
            array9[4] = Lang.menu[144].Value;
            array9[5] = Lang.menu[5].Value;
            array[0] = true;
            if (!MenuServerMode.HasFlag(ServerMode.Lobby))
            {
                MenuServerMode = ServerMode.None;
                array[2] = true;
                array[3] = true;
                array9[1] = Lang.menu[136].Value;
                array9[2] = "";
                array9[3] = "";
            }
            else
            {
                array9[1] = Lang.menu[137].Value;
                if (MenuServerMode.HasFlag(ServerMode.FriendsCanJoin))
                {
                    array9[2] = Lang.menu[139].Value;
                    if (MenuServerMode.HasFlag(ServerMode.FriendsOfFriends))
                    {
                        array9[3] = Lang.menu[143].Value;
                    }
                    else
                    {
                        array9[3] = Lang.menu[142].Value;
                    }
                }
                else
                {
                    array9[2] = Lang.menu[138].Value;
                    if (MenuServerMode.HasFlag(ServerMode.FriendsOfFriends))
                    {
                        array9[3] = Lang.menu[141].Value;
                    }
                    else
                    {
                        array9[3] = Lang.menu[140].Value;
                    }
                }
            }
            if (flag5)
            {
                flag5 = false;
                selectedMenu = 5;
            }
            switch (selectedMenu)
            {
            case 1:
                MenuServerMode ^= ServerMode.Lobby;
                SoundEngine.PlaySound(12);
                break;
            case 2:
                MenuServerMode ^= ServerMode.FriendsCanJoin;
                SoundEngine.PlaySound(12);
                break;
            case 3:
                MenuServerMode ^= ServerMode.FriendsOfFriends;
                SoundEngine.PlaySound(12);
                break;
            case 4:
                clrInput();
                Netplay.ServerPassword = "";
                GetInputText("");
                autoPass = false;
                menuMode = 30;
                SoundEngine.PlaySound(10);
                break;
            case 5:
                menuMode = 6;
                SoundEngine.PlaySound(11);
                break;
            }
        }
        else if (menuMode == 15)
        {
            num5 = 2;
            array9[0] = statusText;
            array[0] = true;
            num2 = 80;
            num4 = 400;
            array9[1] = Lang.menu[5].Value;
            if (selectedMenu == 1 || flag5)
            {
                flag5 = false;
                Netplay.Disconnect = true;
                SoundEngine.PlaySound(11);
                menuMode = 0;
                netMode = 0;
            }
        }
        else if (menuMode == 200)
        {
            num5 = 3;
            array9[0] = Lang.menu[9].Value;
            array[0] = true;
            num2 -= 30;
            array4[1] = 70;
            array4[2] = 50;
            array9[1] = Lang.menu[10].Value;
            array9[2] = Lang.menu[6].Value;
            if (selectedMenu == 1)
            {
                if (FileUtilities.Exists(worldPathName + ".bak", ActiveWorldFileData.IsCloudSave))
                {
                    FileUtilities.Move(worldPathName, worldPathName + ".bad", ActiveWorldFileData.IsCloudSave);
                    FileUtilities.Move(worldPathName + ".bak", worldPathName, ActiveWorldFileData.IsCloudSave);
                    SoundEngine.PlaySound(10);
                    WorldGen.playWorld();
                    menuMode = 10;
                }
                else
                {
                    SoundEngine.PlaySound(11);
                    menuMode = 0;
                    netMode = 0;
                }
            }
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                SoundEngine.PlaySound(11);
                menuMode = 0;
                netMode = 0;
            }
        }
        else if (menuMode == 201)
        {
            num5 = 3;
            array9[0] = Lang.menu[9].Value;
            array[0] = true;
            array[1] = true;
            num2 -= 30;
            array4[1] = -30;
            array4[2] = 50;
            array9[1] = Lang.menu[11].Value;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                SoundEngine.PlaySound(11);
                menuMode = 0;
                netMode = 0;
            }
        }
        else if (menuMode == 10)
        {
            num5 = 1;
            array9[0] = statusText;
            array[0] = true;
            num2 = 300;
            gameTips.Update();
            gameTips.Draw();
        }
        else if (menuMode == 100)
        {
            num5 = 1;
            array9[0] = statusText;
            array[0] = true;
            num2 = 300;
        }
        else if (menuMode == 0)
        {
            _blockFancyUIWhileLoading = false;
            _pendingCharacterSelect = null;
            DD2Event.Ongoing = false;
            eclipse = false;
            pumpkinMoon = false;
            snowMoon = false;
            ServerSideCharacter = false;
            menuMultiplayer = false;
            menuServer = false;
            netMode = 0;
            ClearVisualPostProcessEffects();
            int num11 = 0;
            num2 = 220;
            num5 = 7;
            num4 = 52;
            array9[num11] = Lang.menu[12].Value;
            if (selectedMenu == num11)
            {
                SoundEngine.PlaySound(10);
                ClearPendingPlayerSelectCallbacks();
                menuMode = 1;
            }
            num11++;
            array9[num11] = Lang.menu[13].Value;
            if (selectedMenu == num11)
            {
                SoundEngine.PlaySound(10);
                menuMode = 12;
            }
            num11++;
            array9[num11] = Lang.menu[131].Value;
            if (selectedMenu == num11)
            {
                SoundEngine.PlaySound(10);
                menuMode = 888;
                MenuUI.SetState(AchievementsMenu);
            }
            num11++;
            if (SocialAPI.Workshop != null)
            {
                array9[num11] = Language.GetText("UI.Workshop").Value;
                if (selectedMenu == num11)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 888;
                    UIWorkshopHub uIWorkshopHub = new UIWorkshopHub(null);
                    uIWorkshopHub.EnterHub();
                    MenuUI.SetState(uIWorkshopHub);
                }
            }
            else
            {
                array9[num11] = Language.GetText("UI.ResourcePacks").Value;
                if (selectedMenu == num11)
                {
                    SoundEngine.PlaySound(10);
                    OpenResourcePacksMenu(null);
                }
            }
            num11++;
            array9[num11] = Lang.menu[14].Value;
            if (selectedMenu == num11)
            {
                SoundEngine.PlaySound(10);
                menuMode = 11;
            }
            num11++;
            array9[num11] = Language.GetText("UI.Credits").Value;
            if (selectedMenu == num11)
            {
                SoundEngine.PlaySound(10);
                menuMode = 3000;
                SkyManager.Instance.Activate("CreditsRoll", default(Vector2));
            }
            num11++;
            array9[num11] = Lang.menu[15].Value;
            if (selectedMenu == num11)
            {
                GameAskedToQuit = true;
            }
            num11++;
        }
        else if (menuMode == 1)
        {
            OpenCharacterSelectUI();
        }
        else if (menuMode == 2)
        {
            flag4 = true;
            if (selectedMenu == 0)
            {
                menuMode = 17;
                SoundEngine.PlaySound(10);
                selColor = PendingPlayer.hairColor;
            }
            if (selectedMenu == 1)
            {
                menuMode = 18;
                SoundEngine.PlaySound(10);
                selColor = PendingPlayer.eyeColor;
            }
            if (selectedMenu == 2)
            {
                menuMode = 19;
                SoundEngine.PlaySound(10);
                selColor = PendingPlayer.skinColor;
            }
            if (selectedMenu == 3)
            {
                menuMode = 20;
                SoundEngine.PlaySound(10);
            }
            array9[0] = Lang.menu[18].Value;
            array9[1] = Lang.menu[19].Value;
            array9[2] = Lang.menu[20].Value;
            array9[3] = Lang.menu[21].Value;
            num2 = 220;
            for (int num12 = 0; num12 < 9; num12++)
            {
                if (num12 < 6)
                {
                    array7[num12] = 0.75f;
                }
                else
                {
                    array7[num12] = 0.9f;
                }
            }
            num4 = 38;
            array4[6] = 6;
            array4[7] = 12;
            array4[8] = 18;
            num7 = screenWidth / 2 - 16;
            num8 = 176;
            if (PendingPlayer.Male)
            {
                array9[4] = Lang.menu[22].Value;
            }
            else
            {
                array9[4] = Lang.menu[23].Value;
            }
            if (selectedMenu == 4)
            {
                if (PendingPlayer.Male)
                {
                    SoundEngine.PlaySound(20);
                    PendingPlayer.Male = false;
                }
                else
                {
                    SoundEngine.PlaySound(1);
                    PendingPlayer.Male = true;
                }
            }
            if (PendingPlayer.difficulty == 2)
            {
                array9[5] = Lang.menu[24].Value;
                array6[5] = PendingPlayer.difficulty;
            }
            else if (PendingPlayer.difficulty == 1)
            {
                array9[5] = Lang.menu[25].Value;
                array6[5] = PendingPlayer.difficulty;
            }
            else
            {
                array9[5] = Lang.menu[26].Value;
            }
            if (selectedMenu == 5)
            {
                SoundEngine.PlaySound(10);
                menuMode = 222;
            }
            if (selectedMenu == 7)
            {
                SoundEngine.PlaySound(12);
                PendingPlayer.hair = rand.Next(51);
                PendingPlayer.eyeColor = randColor();
                while (PendingPlayer.eyeColor.R + PendingPlayer.eyeColor.G + PendingPlayer.eyeColor.B > 300)
                {
                    PendingPlayer.eyeColor = randColor();
                }
                PendingPlayer.hairColor = randColor();
                PendingPlayer.pantsColor = randColor();
                PendingPlayer.shirtColor = randColor();
                PendingPlayer.shoeColor = randColor();
                PendingPlayer.skinColor = randColor();
                float num13 = (float)rand.Next(60, 120) * 0.01f;
                if (num13 > 1f)
                {
                    num13 = 1f;
                }
                PendingPlayer.skinColor.R = (byte)((float)rand.Next(240, 255) * num13);
                PendingPlayer.skinColor.G = (byte)((float)rand.Next(110, 140) * num13);
                PendingPlayer.skinColor.B = (byte)((float)rand.Next(75, 110) * num13);
                PendingPlayer.underShirtColor = randColor();
                int num14 = PendingPlayer.hair + 1;
                if (num14 == 5 || num14 == 6 || num14 == 7 || num14 == 10 || num14 == 12 || num14 == 19 || num14 == 22 || num14 == 23 || num14 == 26 || num14 == 27 || num14 == 30 || num14 == 33)
                {
                    PendingPlayer.Male = false;
                }
                else
                {
                    PendingPlayer.Male = true;
                }
                PendingPlayer.skinVariant = rand.Next(PlayerVariantID.Count);
            }
            array9[7] = Lang.menu[27].Value;
            array9[6] = Lang.menu[28].Value;
            array9[8] = Lang.menu[5].Value;
            num5 = 9;
            if (selectedMenu == 8 || flag5)
            {
                flag5 = false;
                SoundEngine.PlaySound(11);
                menuMode = 1;
            }
            else if (selectedMenu == 6)
            {
                SoundEngine.PlaySound(10);
                PendingPlayer.name = "";
                menuMode = 3;
                clrInput();
            }
        }
        else if (menuMode == 222)
        {
            if (focusMenu == 3)
            {
                array9[0] = Lang.menu[29].Value;
            }
            else if (focusMenu == 2)
            {
                array9[0] = Lang.menu[30].Value;
            }
            else if (focusMenu == 1)
            {
                array9[0] = Lang.menu[31].Value;
            }
            else
            {
                array9[0] = Lang.menu[32].Value;
            }
            num4 = 50;
            array4[1] = 25;
            array4[2] = 25;
            array4[3] = 25;
            array[0] = true;
            array9[1] = Lang.menu[26].Value;
            array9[2] = Lang.menu[25].Value;
            array6[2] = 1;
            array9[3] = Lang.menu[24].Value;
            array6[3] = 2;
            num5 = 4;
            if (selectedMenu == 1)
            {
                PendingPlayer.difficulty = 0;
                menuMode = 2;
            }
            else if (selectedMenu == 2)
            {
                menuMode = 2;
                PendingPlayer.difficulty = 1;
            }
            else if (selectedMenu == 3)
            {
                PendingPlayer.difficulty = 2;
                menuMode = 2;
            }
        }
        else if (menuMode == 20)
        {
            flag4 = true;
            if (selectedMenu == 0)
            {
                menuMode = 21;
                SoundEngine.PlaySound(10);
                selColor = PendingPlayer.shirtColor;
            }
            if (selectedMenu == 1)
            {
                menuMode = 22;
                SoundEngine.PlaySound(10);
                selColor = PendingPlayer.underShirtColor;
            }
            if (selectedMenu == 2)
            {
                menuMode = 23;
                SoundEngine.PlaySound(10);
                selColor = PendingPlayer.pantsColor;
            }
            if (selectedMenu == 3)
            {
                selColor = PendingPlayer.shoeColor;
                menuMode = 24;
                SoundEngine.PlaySound(10);
            }
            if (selectedMenu == 5 || flag5)
            {
                flag5 = false;
                SoundEngine.PlaySound(11);
                menuMode = 2;
            }
            if (selectedMenu == 4)
            {
                SoundEngine.PlaySound(12);
                CycleClothingStyle(PendingPlayer);
            }
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            num2 = 260;
            num4 = 50;
            num5 = 6;
            array9[0] = Lang.menu[33].Value;
            array9[1] = Lang.menu[34].Value;
            array9[2] = Lang.menu[35].Value;
            array9[3] = Lang.menu[36].Value;
            array9[4] = Lang.menu[127].Value;
            array9[5] = Lang.menu[5].Value;
            array4[5] = 20;
        }
        else if (menuMode == 17)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 390;
            num2 = 260;
            num4 = 60;
            PendingPlayer.hairColor = selColor;
            num5 = 3;
            array9[0] = Lang.menu[37].Value + " " + (PendingPlayer.hair + 1);
            array9[1] = Lang.menu[38].Value;
            array[1] = true;
            array4[2] = 150;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            int num15 = 51;
            if (focusMenu == 0)
            {
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 9;
            }
            if (selectedMenu == 0)
            {
                SoundEngine.PlaySound(12);
                PendingPlayer.hair++;
                if (PendingPlayer.hair >= num15)
                {
                    PendingPlayer.hair = 0;
                }
            }
            else if (selectedMenu2 == 0)
            {
                SoundEngine.PlaySound(12);
                PendingPlayer.hair--;
                if (PendingPlayer.hair < 0)
                {
                    PendingPlayer.hair = num15 - 1;
                }
            }
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 2;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 18)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 370;
            num2 = 240;
            num4 = 60;
            PendingPlayer.eyeColor = selColor;
            num5 = 3;
            array9[0] = "";
            array9[1] = Lang.menu[39].Value;
            array[1] = true;
            array4[2] = 170;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 2;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 19)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 370;
            num2 = 240;
            num4 = 60;
            PendingPlayer.skinColor = selColor;
            num5 = 3;
            array9[0] = "";
            array9[1] = Lang.menu[40].Value;
            array[1] = true;
            array4[2] = 170;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 2;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 21)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 370;
            num2 = 240;
            num4 = 60;
            PendingPlayer.shirtColor = selColor;
            num5 = 3;
            array9[0] = "";
            array9[1] = Lang.menu[41].Value;
            array[1] = true;
            array4[2] = 170;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 20;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 22)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 370;
            num2 = 240;
            num4 = 60;
            PendingPlayer.underShirtColor = selColor;
            num5 = 3;
            array9[0] = "";
            array9[1] = Lang.menu[42].Value;
            array[1] = true;
            array4[2] = 170;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 20;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 23)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 370;
            num2 = 240;
            num4 = 60;
            PendingPlayer.pantsColor = selColor;
            num5 = 3;
            array9[0] = "";
            array9[1] = Lang.menu[43].Value;
            array[1] = true;
            array4[2] = 170;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 20;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 24)
        {
            flag4 = true;
            num7 = screenWidth / 2 - 16;
            num8 = 210;
            flag = true;
            num9 = 370;
            num2 = 240;
            num4 = 60;
            PendingPlayer.shoeColor = selColor;
            num5 = 3;
            array9[0] = "";
            array9[1] = Lang.menu[44].Value;
            array[1] = true;
            array4[2] = 170;
            array4[1] = 10;
            array9[2] = Lang.menu[5].Value;
            if (selectedMenu == 2 || flag5)
            {
                flag5 = false;
                menuMode = 20;
                SoundEngine.PlaySound(11);
            }
        }
        else if (menuMode == 3)
        {
            UIVirtualKeyboard uIVirtualKeyboard3 = new UIVirtualKeyboard(Lang.menu[45].Value, "", OnCharacterNamed, CreateGoToMenuEvent(2));
            uIVirtualKeyboard3.SetMaxInputLength(20);
            menuMode = 888;
            MenuUI.SetState(uIVirtualKeyboard3);
        }
        else if (menuMode != 4)
        {
            if (menuMode == 5)
            {
                array9[0] = Lang.menu[46].Value + " " + PlayerList[selectedPlayer].Player.name + "?";
                array[0] = true;
                array9[1] = Lang.menu[104].Value;
                array9[2] = Lang.menu[105].Value;
                num5 = 3;
                if (selectedMenu == 1)
                {
                    ErasePlayer(selectedPlayer);
                    SoundEngine.PlaySound(10);
                    menuMode = 1;
                }
                else if (selectedMenu == 2 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 1;
                }
            }
            else if (menuMode == 6)
            {
                menuMode = 888;
                MenuUI.SetState(_worldSelectMenu);
            }
            else if (menuMode == -7)
            {
                num2 = 200;
                num4 = 60;
                array4[2] = 30;
                array4[3] = 30;
                array4[4] = 30;
                array6[3] = 1;
                array6[4] = 2;
                array4[5] = 70;
                if (focusMenu == 2)
                {
                    array9[1] = Language.GetTextValue("UI.WorldDescriptionNormal");
                }
                else if (focusMenu == 3)
                {
                    array9[1] = Language.GetTextValue("UI.WorldDescriptionExpert");
                }
                else if (focusMenu == 4)
                {
                    array9[1] = Language.GetTextValue("UI.WorldDescriptionMaster");
                }
                array9[0] = Lang.menu[32].Value;
                array[0] = true;
                array[1] = true;
                array9[2] = Language.GetTextValue("UI.Normal");
                array9[3] = Language.GetTextValue("UI.Expert");
                array9[4] = Language.GetTextValue("UI.Master");
                array9[5] = Language.GetTextValue("UI.Back");
                num5 = 6;
                if (selectedMenu == 2)
                {
                    GameMode = 0;
                    SoundEngine.PlaySound(10);
                    menuMode = 7;
                    if (SettingsUnlock_WorldEvil)
                    {
                        menuMode = -71;
                    }
                }
                else if (selectedMenu == 3)
                {
                    GameMode = 1;
                    SoundEngine.PlaySound(10);
                    menuMode = 7;
                    if (SettingsUnlock_WorldEvil)
                    {
                        menuMode = -71;
                    }
                }
                else if (selectedMenu == 4)
                {
                    GameMode = 2;
                    SoundEngine.PlaySound(10);
                    menuMode = 7;
                    if (SettingsUnlock_WorldEvil)
                    {
                        menuMode = -71;
                    }
                }
                else if (selectedMenu == 5 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 16;
                }
                clrInput();
            }
            else if (menuMode == -71)
            {
                num2 = 200;
                num4 = 60;
                array4[1] = 30;
                array4[2] = 30;
                array4[3] = 30;
                array4[4] = 70;
                num5 = 5;
                int num16 = 0;
                array9[num16] = Lang.misc[100].Value;
                array[num16] = true;
                num16++;
                array9[num16] = Lang.misc[101].Value;
                if (selectedMenu == num16)
                {
                    WorldGen.WorldGenParam_Evil = 0;
                    SoundEngine.PlaySound(10);
                    menuMode = 7;
                }
                num16++;
                array9[num16] = Lang.misc[102].Value;
                if (selectedMenu == num16)
                {
                    WorldGen.WorldGenParam_Evil = 1;
                    SoundEngine.PlaySound(10);
                    menuMode = 7;
                }
                num16++;
                array9[num16] = Lang.misc[103].Value;
                if (selectedMenu == num16)
                {
                    WorldGen.WorldGenParam_Evil = -1;
                    SoundEngine.PlaySound(10);
                    menuMode = 7;
                }
                num16++;
                array9[num16] = Language.GetTextValue("UI.Back");
                if (selectedMenu == num16 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = -7;
                }
                num16++;
                clrInput();
            }
            else if (menuMode == 7)
            {
                menuMode = 888;
                MenuUI.SetState(new UIVirtualKeyboard(Lang.menu[48].Value, "", OnWorldNamed, CreateGoToMenuEvent(-7)));
            }
            else if (menuMode == 5000)
            {
                menuMode = 888;
                MenuUI.SetState(new UIVirtualKeyboard(Language.GetTextValue("UI.EnterSeed"), "", OnSeedSelected, CreateGoToMenuEvent(7), 0, allowEmpty: true));
            }
            else if (menuMode == 8)
            {
                num2 = 180;
                num4 = 40;
                num5 = 8;
                array4[7] += 30;
                for (int num17 = 0; num17 < num5; num17++)
                {
                    array7[num17] = 0.8f;
                }
                array9[7] = Lang.menu[5].Value;
                for (int num18 = 0; num18 < 7; num18++)
                {
                    if (num18 < WorldList.Count)
                    {
                        array9[num18] = WorldList[num18 + menuSkip].Name;
                        if (WorldList[num18 + menuSkip].GameMode == 1)
                        {
                            array6[num18] = 1;
                        }
                        else if (WorldList[num18 + menuSkip].GameMode == 2)
                        {
                            array6[num18] = 2;
                        }
                    }
                    else
                    {
                        array9[num18] = null;
                    }
                }
                if (WorldList.Count > 7 + menuSkip)
                {
                    array9[6] = Language.GetTextValue("UI.More");
                    array9[6] = "▼";
                    array7[6] = 0.6f;
                    array4[6] += 8;
                    menuWide[6] = true;
                }
                if (menuSkip > 0)
                {
                    array9[0] = "▲";
                    array7[0] = 0.6f;
                    array4[0] += 8;
                    menuWide[0] = true;
                }
                if (selectedMenu == 0 && menuSkip > 0)
                {
                    SoundEngine.PlaySound(12);
                    menuSkip -= 5;
                    if (menuSkip < 0)
                    {
                        menuSkip = 0;
                    }
                }
                else if (selectedMenu == 6 && menuSkip < WorldList.Count - 7)
                {
                    SoundEngine.PlaySound(12);
                    menuSkip += 5;
                    if (menuSkip >= PlayerList.Count - 7)
                    {
                        menuSkip = WorldList.Count - 7;
                    }
                }
                else if (selectedMenu == 7 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 6;
                }
                else if (selectedMenu >= 0)
                {
                    selectedWorld = selectedMenu + menuSkip;
                    SoundEngine.PlaySound(10);
                    menuMode = 9;
                }
            }
            else if (menuMode == 9)
            {
                array9[0] = Lang.menu[46].Value + " " + WorldList[selectedWorld].Name + "?";
                array[0] = true;
                array9[1] = Lang.menu[104].Value;
                array9[2] = Lang.menu[105].Value;
                num5 = 3;
                if (selectedMenu == 1)
                {
                    EraseWorld(selectedWorld);
                    SoundEngine.PlaySound(10);
                    menuMode = 6;
                }
                else if (selectedMenu == 2 || flag5)
                {
                    SoundEngine.PlaySound(11);
                    menuMode = 6;
                }
            }
            else if (menuMode == 3000)
            {
                num5 = 1;
                num2 = 500;
                array7[0] = 0.9f;
                array9[0] = Lang.menu[5].Value;
                if (selectedMenu == 0 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 0;
                }
            }
            else if (menuMode == 11)
            {
                num2 = 210;
                num4 = 37;
                num5 = 8;
                array4[num5 - 1] = 8;
                for (int num19 = 0; num19 < num5; num19++)
                {
                    array7[num19] = 0.75f;
                }
                int num20 = 0;
                array9[num20] = Lang.menu[114].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 112;
                }
                num20++;
                array9[num20] = Lang.menu[210].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 1112;
                }
                num20++;
                array9[num20] = Lang.menu[63].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 1111;
                }
                num20++;
                array9[num20] = Lang.menu[65].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(11);
                    menuMode = 26;
                }
                num20++;
                array9[num20] = Lang.menu[218].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 1125;
                }
                num20++;
                array9[num20] = Lang.menu[219].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 1127;
                }
                num20++;
                array9[num20] = Lang.menu[103].Value;
                if (selectedMenu == num20)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 1213;
                }
                num20++;
                array9[num20] = Lang.menu[5].Value;
                if (selectedMenu == num20 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 0;
                    SaveSettings();
                }
            }
            else if (menuMode == 112)
            {
                num2 = 250;
                num4 = 52;
                num5 = 5;
                array4[num5 - 1] = 18;
                for (int num21 = 0; num21 < num5; num21++)
                {
                    array7[num21] = 0.78f;
                }
                int num22 = 0;
                if (autoSave)
                {
                    array9[num22] = Lang.menu[67].Value;
                }
                else
                {
                    array9[num22] = Lang.menu[68].Value;
                }
                if (selectedMenu == num22)
                {
                    SoundEngine.PlaySound(12);
                    if (autoSave)
                    {
                        autoSave = false;
                    }
                    else
                    {
                        autoSave = true;
                    }
                }
                num22++;
                if (autoPause)
                {
                    array9[num22] = Lang.menu[69].Value;
                }
                else
                {
                    array9[num22] = Lang.menu[70].Value;
                }
                if (selectedMenu == num22)
                {
                    SoundEngine.PlaySound(12);
                    if (autoPause)
                    {
                        autoPause = false;
                    }
                    else
                    {
                        autoPause = true;
                    }
                }
                num22++;
                if (mapEnabled)
                {
                    array9[num22] = Lang.menu[112].Value;
                }
                else
                {
                    array9[num22] = Lang.menu[113].Value;
                }
                if (selectedMenu == num22)
                {
                    SoundEngine.PlaySound(12);
                    if (mapEnabled)
                    {
                        mapEnabled = false;
                    }
                    else
                    {
                        mapEnabled = true;
                    }
                }
                num22++;
                array9[num22] = (HidePassword ? Lang.menu[212].Value : Lang.menu[211].Value);
                if (selectedMenu == num22)
                {
                    SoundEngine.PlaySound(12);
                    HidePassword = !HidePassword;
                }
                num22++;
                array9[num22] = Lang.menu[5].Value;
                if (selectedMenu == num22 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 1112)
            {
                num2 = 210;
                num4 = 32;
                num5 = 10;
                array4[num5 - 1] = 18;
                for (int num23 = 0; num23 < num5; num23++)
                {
                    array7[num23] = 0.7f;
                }
                int num24 = 0;
                if (showItemText)
                {
                    array9[num24] = Lang.menu[71].Value;
                }
                else
                {
                    array9[num24] = Lang.menu[72].Value;
                }
                if (selectedMenu == num24)
                {
                    SoundEngine.PlaySound(12);
                    if (showItemText)
                    {
                        showItemText = false;
                    }
                    else
                    {
                        showItemText = true;
                    }
                }
                num24++;
                array9[num24] = Lang.menu[123].Value + " " + Lang.menu[124 + invasionProgressMode].Value;
                if (selectedMenu == num24)
                {
                    SoundEngine.PlaySound(12);
                    invasionProgressMode++;
                    if (invasionProgressMode >= 3)
                    {
                        invasionProgressMode = 0;
                    }
                }
                num24++;
                array9[num24] = (placementPreview ? Lang.menu[128].Value : Lang.menu[129].Value);
                if (selectedMenu == num24)
                {
                    SoundEngine.PlaySound(12);
                    placementPreview = !placementPreview;
                }
                num24++;
                array9[num24] = (ItemSlot.Options.HighlightNewItems ? Lang.inter[117].Value : Lang.inter[116].Value);
                if (selectedMenu == num24)
                {
                    SoundEngine.PlaySound(12);
                    ItemSlot.Options.HighlightNewItems = !ItemSlot.Options.HighlightNewItems;
                }
                num24++;
                array9[num24] = (MouseShowBuildingGrid ? Lang.menu[229].Value : Lang.menu[230].Value);
                if (selectedMenu == num24)
                {
                    SoundEngine.PlaySound(12);
                    MouseShowBuildingGrid = !MouseShowBuildingGrid;
                }
                num24++;
                array9[num24] = (GamepadDisableInstructionsDisplay ? Lang.menu[241].Value : Lang.menu[242].Value);
                if (selectedMenu == num24)
                {
                    SoundEngine.PlaySound(12);
                    GamepadDisableInstructionsDisplay = !GamepadDisableInstructionsDisplay;
                }
                num24++;
                string textValue = Language.GetTextValue("UI.MinimapFrame_" + MinimapFrameManagerInstance.ActiveSelectionKeyName);
                array9[num24] = Language.GetTextValue("UI.SelectMapBorder", textValue);
                if (selectedMenu == num24)
                {
                    MinimapFrameManagerInstance.CycleSelection();
                }
                num24++;
                string activeSetKeyName = ResourceSetsManager.ActiveSetKeyName;
                string textValue2 = Language.GetTextValue("UI.HealthManaStyle_" + activeSetKeyName);
                array9[num24] = Language.GetTextValue("UI.SelectHealthStyle", textValue2);
                if (selectedMenu == num24)
                {
                    ResourceSetsManager.CycleResourceSet();
                }
                num24++;
                array9[num24] = Language.GetTextValue(BigProgressBarSystem.ShowText ? "UI.ShowBossLifeTextOn" : "UI.ShowBossLifeTextOff");
                if (selectedMenu == num24)
                {
                    BigProgressBarSystem.ToggleShowText();
                }
                num24++;
                array9[num24] = Lang.menu[5].Value;
                if (selectedMenu == num24 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 1111)
            {
                bgScroll = (int)Math.Round((1f - caveParallax) * 500f);
                int num25 = 0;
                array9[num25] = Lang.menu[51].Value;
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 111;
                }
                num25++;
                array9[num25] = Lang.menu[52].Value;
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(11);
                    menuMode = 28;
                }
                num25++;
                array9[num25] = Lang.menu[(int)(247 + FrameSkipMode)].Value;
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    CycleFrameSkipMode();
                }
                num25++;
                array9[num25] = Language.GetTextValue("UI.LightMode_" + Lighting.Mode);
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    Lighting.NextLightMode();
                }
                num25++;
                switch (qaStyle)
                {
                case 0:
                    array9[num25] = Lang.menu[59].Value;
                    break;
                case 1:
                    array9[num25] = Lang.menu[60].Value;
                    break;
                case 2:
                    array9[num25] = Lang.menu[61].Value;
                    break;
                default:
                    array9[num25] = Lang.menu[62].Value;
                    break;
                }
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    if (++qaStyle > 3)
                    {
                        qaStyle = 0;
                    }
                }
                num25++;
                array9[num25] = (BackgroundEnabled ? Lang.menu[100].Value : Lang.menu[101].Value);
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    BackgroundEnabled = !BackgroundEnabled;
                }
                num25++;
                array9[num25] = (ChildSafety.Disabled ? Lang.menu[132].Value : Lang.menu[133].Value);
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    ChildSafety.Disabled = !ChildSafety.Disabled;
                }
                num25++;
                array9[num25] = (SettingsEnabled_MinersWobble ? Lang.menu[250].Value : Lang.menu[251].Value);
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    SettingsEnabled_MinersWobble = !SettingsEnabled_MinersWobble;
                }
                num25++;
                array9[num25] = (SettingsEnabled_TilesSwayInWind ? Language.GetTextValue("UI.TilesSwayInWindOn") : Language.GetTextValue("UI.TilesSwayInWindOff"));
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(12);
                    SettingsEnabled_TilesSwayInWind = !SettingsEnabled_TilesSwayInWind;
                }
                num25++;
                array9[num25] = Language.GetTextValue("UI.Effects");
                if (selectedMenu == num25)
                {
                    SoundEngine.PlaySound(11);
                    menuMode = 2008;
                }
                int num26 = num25;
                int num27 = num26;
                array9[num27] = Lang.menu[5].Value;
                array4[num27] = 8;
                if (selectedMenu == num27 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    SaveSettings();
                    menuMode = 11;
                }
                num2 = 186;
                num4 = 30;
                num5 = num27 + 1;
                for (int num28 = 0; num28 < num26; num28++)
                {
                    array7[num28] = 0.6f;
                }
            }
            else if (menuMode == 2008)
            {
                num2 = 240;
                num4 = 60;
                num5 = 6;
                array9[0] = "";
                array9[1] = Language.GetTextValue("UI.Effects");
                array[1] = true;
                array4[1] = 10;
                array9[2] = Language.GetTextValue("GameUI.StormEffects", UseStormEffects ? Language.GetTextValue("GameUI.Enabled") : Language.GetTextValue("GameUI.Disabled"));
                array7[2] = 0.8f;
                array9[3] = Language.GetTextValue("GameUI.HeatDistortion", UseHeatDistortion ? Language.GetTextValue("GameUI.Enabled") : Language.GetTextValue("GameUI.Disabled"));
                array7[3] = 0.8f;
                array9[4] = Language.GetTextValue("GameUI.WaveQuality", WaveQuality switch
                {
                    1 => Language.GetTextValue("GameUI.QualityLow"), 
                    2 => Language.GetTextValue("GameUI.QualityMedium"), 
                    3 => Language.GetTextValue("GameUI.QualityHigh"), 
                    _ => Language.GetTextValue("GameUI.QualityOff"), 
                });
                array7[4] = 0.8f;
                array9[5] = Lang.menu[5].Value;
                if (selectedMenu == 2)
                {
                    UseStormEffects = !UseStormEffects;
                }
                if (selectedMenu == 3)
                {
                    UseHeatDistortion = !UseHeatDistortion;
                }
                if (selectedMenu == 4)
                {
                    WaveQuality = (WaveQuality + 1) % 4;
                }
                if (selectedMenu == 5 || flag5)
                {
                    flag5 = false;
                    menuMode = 1111;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 111)
            {
                for (int num29 = 0; num29 < 9; num29++)
                {
                    array7[num29] = 0.85f;
                }
                num2 = 210;
                num4 = 55;
                int num30 = 0;
                array9[num30] = Lang.menu[73].Value + ": " + PendingResolutionWidth + "x" + PendingResolutionHeight;
                if (selectedMenu == num30)
                {
                    SoundEngine.PlaySound(12);
                    int num31 = 0;
                    for (int num32 = 0; num32 < numDisplayModes; num32++)
                    {
                        if (displayWidth[num32] == PendingResolutionWidth && displayHeight[num32] == PendingResolutionHeight)
                        {
                            num31 = num32;
                            break;
                        }
                    }
                    num31 = (num31 + 1) % numDisplayModes;
                    PendingResolutionWidth = displayWidth[num31];
                    PendingResolutionHeight = displayHeight[num31];
                }
                num30++;
                if (IsBorderlessDisplayAvailable())
                {
                    array9[num30] = Lang.menu[PendingBorderlessState ? 245 : 246].Value;
                    if (selectedMenu == num30)
                    {
                        SoundEngine.PlaySound(12);
                        PendingBorderlessState = !PendingBorderlessState;
                    }
                    num30++;
                }
                array9[num30] = (graphics.IsFullScreen ? Lang.menu[49].Value : Lang.menu[50].Value);
                if (selectedMenu == num30)
                {
                    ToggleFullScreen();
                }
                num30++;
                array4[num30] = 100;
                array9[num30] = Lang.menu[134].Value;
                if (selectedMenu == num30)
                {
                    if (graphics.IsFullScreen || PendingBorderlessState != screenBorderless || PendingResolutionWidth != screenWidth || PendingResolutionHeight != screenHeight)
                    {
                        screenBorderless = PendingBorderlessState;
                        screenBorderlessPendingResizes = (screenBorderless ? 6 : 0);
                        SetResolution(PendingResolutionWidth, PendingResolutionHeight);
                    }
                    SoundEngine.PlaySound(11);
                    menuMode = 1111;
                }
                num30++;
                array9[num30] = Lang.menu[5].Value;
                array4[num30] = 100;
                if (selectedMenu == num30 || flag5)
                {
                    flag5 = false;
                    PendingResolutionWidth = graphics.PreferredBackBufferWidth;
                    PendingResolutionHeight = graphics.PreferredBackBufferHeight;
                    PendingBorderlessState = screenBorderless;
                    menuMode = 1111;
                    SoundEngine.PlaySound(11);
                }
                num30++;
                num5 = num30;
            }
            else if (menuMode == 1125)
            {
                num2 = 232;
                num4 = 38;
                num5 = 7;
                array4[num5 - 1] = 18;
                for (int num33 = 0; num33 < num5; num33++)
                {
                    array7[num33] = 0.73f;
                }
                int num34 = 0;
                array9[num34] = Lang.menu[64].Value;
                if (selectedMenu == num34)
                {
                    SoundEngine.PlaySound(10);
                    selColor = mouseColor;
                    mouseColorSlider.SetHSL(mouseColor);
                    menuMode = 25;
                }
                num34++;
                array9[num34] = Lang.menu[217].Value;
                if (selectedMenu == num34)
                {
                    SoundEngine.PlaySound(10);
                    selColor = MouseBorderColor;
                    mouseBorderColorSlider.SetHSL(mouseColor);
                    menuMode = 252;
                }
                num34++;
                array9[num34] = (cSmartCursorModeIsToggleAndNotHold ? Lang.menu[121].Value : Lang.menu[122].Value);
                if (selectedMenu == num34)
                {
                    SoundEngine.PlaySound(12);
                    cSmartCursorModeIsToggleAndNotHold = !cSmartCursorModeIsToggleAndNotHold;
                }
                num34++;
                array9[num34] = (Player.SmartCursorSettings.SmartAxeAfterPickaxe ? Lang.menu[214].Value : Lang.menu[213].Value);
                if (selectedMenu == num34)
                {
                    SoundEngine.PlaySound(12);
                    Player.SmartCursorSettings.SmartAxeAfterPickaxe = !Player.SmartCursorSettings.SmartAxeAfterPickaxe;
                }
                num34++;
                array9[num34] = (Player.SmartCursorSettings.SmartBlocksEnabled ? Lang.menu[215].Value : Lang.menu[216].Value);
                if (selectedMenu == num34)
                {
                    SoundEngine.PlaySound(12);
                    Player.SmartCursorSettings.SmartBlocksEnabled = !Player.SmartCursorSettings.SmartBlocksEnabled;
                }
                num34++;
                switch (LockOnHelper.UseMode)
                {
                case LockOnHelper.LockOnMode.FocusTarget:
                    array9[num34] = Lang.menu[232].Value;
                    break;
                case LockOnHelper.LockOnMode.TargetClosest:
                    array9[num34] = Lang.menu[233].Value;
                    break;
                case LockOnHelper.LockOnMode.ThreeDS:
                    array9[num34] = Lang.menu[234].Value;
                    break;
                }
                if (selectedMenu == num34)
                {
                    SoundEngine.PlaySound(12);
                    LockOnHelper.CycleUseModes();
                }
                num34++;
                array9[num34] = Lang.menu[5].Value;
                if (selectedMenu == num34 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 25)
            {
                flag = true;
                num9 = 320;
                num2 = 200;
                num4 = 10;
                mouseColor = selColor;
                mouseColorSlider.SetHSL(mouseColor);
                num5 = 3;
                array9[0] = "";
                array9[1] = Lang.menu[64].Value;
                array[1] = true;
                array4[2] = 250;
                array4[1] = 10;
                array9[2] = Lang.menu[5].Value;
                if (selectedMenu == 2 || flag5)
                {
                    flag5 = false;
                    menuMode = 1125;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 252)
            {
                flag = true;
                num9 = 320;
                num2 = 200;
                num4 = 10;
                MouseBorderColor = selColor;
                mouseBorderColorSlider.SetHSL(mouseColor);
                num5 = 3;
                array9[0] = "";
                array9[1] = Lang.menu[217].Value;
                array[1] = true;
                array4[2] = 250;
                array4[1] = 10;
                array9[2] = Lang.menu[5].Value;
                if (selectedMenu == 2 || flag5)
                {
                    flag5 = false;
                    menuMode = 1125;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 26)
            {
                flag2 = true;
                num2 = 200;
                num4 = 10;
                num5 = 3;
                array9[0] = "";
                array9[1] = Lang.menu[65].Value;
                array[1] = true;
                array4[2] = 250;
                array4[1] = 10;
                array9[2] = Lang.menu[5].Value;
                if (selectedMenu == 2 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 28)
            {
                caveParallax = 1f - (float)bgScroll / 500f;
                flag3 = true;
                num2 = 240;
                num4 = 60;
                num5 = 3;
                array9[0] = "";
                array9[1] = Lang.menu[52].Value;
                array[1] = true;
                array4[2] = 170;
                array4[1] = 10;
                array9[2] = Lang.menu[5].Value;
                if (selectedMenu == 2 || flag5)
                {
                    flag5 = false;
                    menuMode = 1111;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 272727)
            {
                num2 = 200;
                num4 = 30;
                num5 = 14;
                string[] array10 = new string[12]
                {
                    cMapStyle, cMapFull, cMapZoomIn, cMapZoomOut, cMapAlphaUp, cMapAlphaDown, null, null, null, null,
                    null, null
                };
                if (setKey >= 0)
                {
                    array10[setKey] = "_";
                }
                array9[0] = Lang.menu[106].Value + array10[0];
                array9[1] = Lang.menu[107].Value + array10[1];
                array9[2] = Lang.menu[108].Value + array10[2];
                array9[3] = Lang.menu[109].Value + array10[3];
                array9[4] = Lang.menu[110].Value + array10[4];
                array9[5] = Lang.menu[111].Value + array10[5];
                for (int num35 = 0; num35 < 6; num35++)
                {
                    array8[num35] = true;
                    array7[num35] = 0.55f;
                    array5[num35] = -140;
                }
                array7[6] = 0.8f;
                array7[6] = 0.8f;
                array4[6] = 6;
                array9[6] = Lang.menu[86].Value;
                array4[7] = 16;
                array9[7] = Lang.menu[5].Value;
                if (selectedMenu == 7 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
                else if (selectedMenu == 6)
                {
                    cMapStyle = "Tab";
                    cMapFull = "M";
                    cMapZoomIn = "Add";
                    cMapZoomOut = "Subtract";
                    cMapAlphaUp = "PageUp";
                    cMapAlphaDown = "PageDown";
                    setKey = -1;
                    SoundEngine.PlaySound(11);
                }
                else if (selectedMenu >= 0)
                {
                    setKey = selectedMenu;
                }
                if (setKey >= 0)
                {
                    List<Microsoft.Xna.Framework.Input.Keys> pressedKeys = PlayerInput.GetPressedKeys();
                    if (pressedKeys.Count > 0)
                    {
                        string text = string.Concat(pressedKeys[0]);
                        if (text != "None")
                        {
                            if (setKey == 0)
                            {
                                cMapStyle = text;
                            }
                            if (setKey == 1)
                            {
                                cMapFull = text;
                            }
                            if (setKey == 2)
                            {
                                cMapZoomIn = text;
                            }
                            if (setKey == 3)
                            {
                                cMapZoomOut = text;
                            }
                            if (setKey == 4)
                            {
                                cMapAlphaUp = text;
                            }
                            if (setKey == 5)
                            {
                                cMapAlphaDown = text;
                            }
                            setKey = -1;
                        }
                    }
                }
            }
            else if (menuMode == 27)
            {
                num2 = 176;
                num4 = 22;
                num5 = 16;
                string[] array11 = new string[14]
                {
                    cUp, cDown, cLeft, cRight, cJump, cThrowItem, cInv, cHeal, cMana, cBuff,
                    cHook, cTorch, cSmart, cMount
                };
                if (setKey >= 0)
                {
                    array11[setKey] = "_";
                }
                array9[0] = Lang.menu[74].Value + array11[0];
                array9[1] = Lang.menu[75].Value + array11[1];
                array9[2] = Lang.menu[76].Value + array11[2];
                array9[3] = Lang.menu[77].Value + array11[3];
                array9[4] = Lang.menu[78].Value + array11[4];
                array9[5] = Lang.menu[79].Value + array11[5];
                array9[6] = Lang.menu[80].Value + array11[6];
                array9[7] = Lang.menu[81].Value + array11[7];
                array9[8] = Lang.menu[82].Value + array11[8];
                array9[9] = Lang.menu[83].Value + array11[9];
                array9[10] = Lang.menu[84].Value + array11[10];
                array9[11] = Lang.menu[85].Value + array11[11];
                array9[12] = Lang.menu[120].Value + array11[12];
                array9[13] = Lang.menu[130].Value + array11[13];
                for (int num36 = 0; num36 < 14; num36++)
                {
                    array8[num36] = true;
                    array7[num36] = 0.45f;
                    array5[num36] = -80;
                }
                array7[14] = 0.8f;
                array4[14] = 6;
                array9[14] = Lang.menu[86].Value;
                array7[15] = 0.8f;
                array4[15] = 16;
                array9[15] = Lang.menu[5].Value;
                if (selectedMenu == 15 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
                else if (selectedMenu == 14)
                {
                    ResetKeyBindings();
                    setKey = -1;
                    SoundEngine.PlaySound(11);
                }
                else if (selectedMenu >= 0)
                {
                    setKey = selectedMenu;
                }
                if (setKey >= 0)
                {
                    List<Microsoft.Xna.Framework.Input.Keys> pressedKeys2 = PlayerInput.GetPressedKeys();
                    if (pressedKeys2.Count > 0)
                    {
                        string text2 = string.Concat(pressedKeys2[0]);
                        if (text2 != "None")
                        {
                            if (setKey == 0)
                            {
                                cUp = text2;
                            }
                            if (setKey == 1)
                            {
                                cDown = text2;
                            }
                            if (setKey == 2)
                            {
                                cLeft = text2;
                            }
                            if (setKey == 3)
                            {
                                cRight = text2;
                            }
                            if (setKey == 4)
                            {
                                cJump = text2;
                            }
                            if (setKey == 5)
                            {
                                cThrowItem = text2;
                            }
                            if (setKey == 6)
                            {
                                cInv = text2;
                            }
                            if (setKey == 7)
                            {
                                cHeal = text2;
                            }
                            if (setKey == 8)
                            {
                                cMana = text2;
                            }
                            if (setKey == 9)
                            {
                                cBuff = text2;
                            }
                            if (setKey == 10)
                            {
                                cHook = text2;
                            }
                            if (setKey == 11)
                            {
                                cTorch = text2;
                            }
                            if (setKey == 12)
                            {
                                cSmart = text2;
                            }
                            if (setKey == 13)
                            {
                                cMount = text2;
                            }
                            setKey = -1;
                        }
                    }
                }
            }
            else if (menuMode == 1127)
            {
                num2 = 250;
                num4 = 52;
                num5 = 4;
                array4[num5 - 1] = 18;
                for (int num37 = 0; num37 < num5; num37++)
                {
                    array7[num37] = 0.78f;
                }
                int num38 = 0;
                array9[num38] = (ReversedUpDownArmorSetBonuses ? Lang.menu[220].Value : Lang.menu[221].Value);
                if (selectedMenu == num38)
                {
                    SoundEngine.PlaySound(12);
                    ReversedUpDownArmorSetBonuses = !ReversedUpDownArmorSetBonuses;
                }
                num38++;
                if (ItemSlot.Options.DisableQuickTrash)
                {
                    array9[num38] = Lang.menu[253].Value;
                }
                else
                {
                    array9[num38] = (ItemSlot.Options.DisableLeftShiftTrashCan ? Lang.menu[224].Value : Lang.menu[223].Value);
                }
                if (selectedMenu == num38)
                {
                    SoundEngine.PlaySound(12);
                    if (ItemSlot.Options.DisableQuickTrash)
                    {
                        ItemSlot.Options.DisableQuickTrash = false;
                        ItemSlot.Options.DisableLeftShiftTrashCan = true;
                    }
                    else if (ItemSlot.Options.DisableLeftShiftTrashCan)
                    {
                        ItemSlot.Options.DisableLeftShiftTrashCan = false;
                    }
                    else
                    {
                        ItemSlot.Options.DisableQuickTrash = true;
                        ItemSlot.Options.DisableLeftShiftTrashCan = false;
                    }
                }
                num38++;
                array9[num38] = Lang.menu[222].Value;
                if (selectedMenu == num38)
                {
                    SoundEngine.PlaySound(10);
                    menuMode = 888;
                    MenuUI.SetState(ManageControlsMenu);
                }
                num38++;
                array9[num38] = Lang.menu[5].Value;
                if (selectedMenu == num38 || flag5)
                {
                    flag5 = false;
                    menuMode = 11;
                    SoundEngine.PlaySound(11);
                }
            }
            else if (menuMode == 12)
            {
                int num39 = ((SocialAPI.Network != null) ? 1 : 0);
                menuServer = false;
                array9[0] = Lang.menu[(SocialAPI.Network != null) ? 146 : 87].Value;
                array9[1] = Lang.menu[145].Value;
                array9[1 + num39] = Lang.menu[88].Value;
                array9[2 + num39] = Lang.menu[5].Value;
                if (selectedMenu == 0)
                {
                    LoadPlayers();
                    menuMultiplayer = true;
                    SoundEngine.PlaySound(10);
                    ClearPendingPlayerSelectCallbacks();
                    menuMode = 1;
                }
                else if (selectedMenu == 1 + num39)
                {
                    LoadPlayers();
                    SoundEngine.PlaySound(10);
                    ClearPendingPlayerSelectCallbacks();
                    menuMode = 1;
                    menuMultiplayer = true;
                    menuServer = true;
                }
                else if (selectedMenu == 1)
                {
                    SoundEngine.PlaySound(10);
                    SocialAPI.Friends.OpenJoinInterface();
                }
                else if (selectedMenu == 2 + num39 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 0;
                }
                num5 = 3 + num39;
            }
            else if (menuMode == 13)
            {
                if (PlayerInput.SettingsForUI.ShowGamepadHints)
                {
                    num2 = 180;
                    num4 = 30;
                    int num40 = 0;
                    array9[num40] = Lang.menu[89].Value.Replace(":", "");
                    if (selectedMenu == num40)
                    {
                        UIVirtualKeyboard state = new UIVirtualKeyboard(Lang.menu[89].Value, getIP, OnSubmitServerIP, CreateGoToMenuEvent(13), 0, allowEmpty: true);
                        UserInterface.ActiveInstance.SetState(state);
                        menuMode = 888;
                    }
                    array7[num40] = 0.6f;
                    array4[num40] = 40;
                    num40++;
                    for (int num41 = 0; num41 <= 6; num41++)
                    {
                        if (recentWorld[num41] != null && recentWorld[num41] != "")
                        {
                            array9[num40] = recentWorld[num41] + " (" + recentIP[num41] + ":" + recentPort[num41] + ")";
                        }
                        else
                        {
                            array9[num40] = "";
                            array[num40] = true;
                        }
                        array7[num40] = 0.6f;
                        array4[num40] = 40;
                        if (selectedMenu == num40)
                        {
                            autoPass = false;
                            Netplay.ListenPort = recentPort[num41];
                            getIP = recentIP[num41];
                            Netplay.SetRemoteIPAsync(getIP, StartClientGameplay);
                            menuMode = 14;
                            statusText = Language.GetTextValue("Net.ConnectingTo", getIP);
                        }
                        num40++;
                    }
                    array4[num40] = 64;
                    array9[num40] = Lang.menu[5].Value;
                    if (selectedMenu == num40 || flag5)
                    {
                        flag5 = false;
                        SoundEngine.PlaySound(11);
                        menuMode = 1;
                    }
                    num40++;
                    num5 = num40;
                }
                else
                {
                    string text3 = getIP;
                    PlayerInput.WritingText = true;
                    instance.HandleIME();
                    getIP = GetInputText(getIP);
                    if (text3 != getIP)
                    {
                        SoundEngine.PlaySound(12);
                    }
                    num5 = 11;
                    num2 = 180;
                    num4 = 30;
                    array9[0] = Lang.menu[89].Value;
                    array[0] = true;
                    array9[1] = getIP;
                    array4[1] = 19;
                    if (textBlinkerState == 1)
                    {
                        array9[1] += "|";
                        array5[1] = 1;
                    }
                    else
                    {
                        array9[1] += " ";
                    }
                    array[1] = true;
                    array4[9] = 44;
                    array9[9] = Lang.menu[4].Value;
                    array2[9] = true;
                    if (getIP != "")
                    {
                        if (getIP.Substring(0, 1) == " ")
                        {
                            getIP = "";
                        }
                        for (int num42 = 0; num42 < getIP.Length; num42++)
                        {
                            if (getIP != " ")
                            {
                                array2[9] = false;
                            }
                        }
                    }
                    array4[10] = 64;
                    array9[10] = Lang.menu[5].Value;
                    for (int num43 = 2; num43 <= 8; num43++)
                    {
                        int num44 = num43 - 2;
                        if (recentWorld[num44] != null && recentWorld[num44] != "")
                        {
                            array9[num43] = recentWorld[num44] + " (" + recentIP[num44] + ":" + recentPort[num44] + ")";
                        }
                        else
                        {
                            array9[num43] = "";
                            array[num43] = true;
                        }
                        array7[num43] = 0.6f;
                        array4[num43] = 40;
                    }
                    if (selectedMenu >= 2 && selectedMenu < 9)
                    {
                        autoPass = false;
                        int num45 = selectedMenu - 2;
                        Netplay.ListenPort = recentPort[num45];
                        getIP = recentIP[num45];
                        Netplay.SetRemoteIPAsync(getIP, StartClientGameplay);
                        menuMode = 14;
                        statusText = Language.GetTextValue("Net.ConnectingTo", getIP);
                    }
                    if (selectedMenu == 10 || flag5)
                    {
                        flag5 = false;
                        SoundEngine.PlaySound(11);
                        menuMode = 1;
                    }
                    if (selectedMenu == 9 || (!array2[2] && inputTextEnter))
                    {
                        OnSubmitServerIP(getIP);
                    }
                    textBlinkerCount++;
                    if (textBlinkerCount >= 20)
                    {
                        if (textBlinkerState == 0)
                        {
                            textBlinkerState = 1;
                        }
                        else
                        {
                            textBlinkerState = 0;
                        }
                        textBlinkerCount = 0;
                    }
                }
            }
            else if (menuMode == 131)
            {
                if (PlayerInput.SettingsForUI.ShowGamepadHints)
                {
                    UIVirtualKeyboard uIVirtualKeyboard4 = new UIVirtualKeyboard(Lang.menu[90].Value, getPort, OnSubmitServerPort, CreateGoToMenuEvent(13), 0, allowEmpty: true);
                    uIVirtualKeyboard4.CustomTextValidationForUpdate = IsGoodPortAddress;
                    uIVirtualKeyboard4.CustomTextValidationForSubmit = IsGoodPortAddress;
                    UserInterface.ActiveInstance.SetState(uIVirtualKeyboard4);
                    menuMode = 888;
                }
                int num46 = 7777;
                PlayerInput.WritingText = true;
                instance.HandleIME();
                string text4 = getPort;
                getPort = GetInputText(getPort);
                if (text4 != getPort)
                {
                    SoundEngine.PlaySound(12);
                }
                array9[0] = Lang.menu[90].Value;
                array2[2] = true;
                if (getPort != "")
                {
                    bool flag7 = false;
                    try
                    {
                        num46 = Convert.ToInt32(getPort);
                        if (num46 > 0 && num46 <= 65535)
                        {
                            flag7 = true;
                        }
                    }
                    catch
                    {
                    }
                    if (flag7)
                    {
                        array2[2] = false;
                    }
                }
                textBlinkerCount++;
                if (textBlinkerCount >= 20)
                {
                    if (textBlinkerState == 0)
                    {
                        textBlinkerState = 1;
                    }
                    else
                    {
                        textBlinkerState = 0;
                    }
                    textBlinkerCount = 0;
                }
                array9[1] = getPort;
                if (textBlinkerState == 1)
                {
                    array9[1] += "|";
                    array5[1] = 1;
                }
                else
                {
                    array9[1] += " ";
                }
                array[0] = true;
                array[1] = true;
                array4[1] = -20;
                array4[2] = 20;
                array9[2] = Lang.menu[4].Value;
                array9[3] = Lang.menu[5].Value;
                num5 = 4;
                if (selectedMenu == 3 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 1;
                }
                if (selectedMenu == 2 || (!array2[2] && inputTextEnter))
                {
                    OnSubmitServerPort(getPort);
                }
            }
            else if (menuMode == 16)
            {
                num2 = 200;
                num4 = 60;
                array4[1] = 30;
                array4[2] = 30;
                array4[3] = 30;
                array4[4] = 70;
                array9[0] = Lang.menu[91].Value;
                array[0] = true;
                array9[1] = Lang.menu[92].Value;
                array9[2] = Lang.menu[93].Value;
                array9[3] = Lang.menu[94].Value;
                array9[4] = Lang.menu[5].Value;
                num5 = 5;
                if (selectedMenu == 4 || flag5)
                {
                    flag5 = false;
                    menuMode = 6;
                    SoundEngine.PlaySound(11);
                }
                else if (selectedMenu > 0)
                {
                    if (selectedMenu == 1)
                    {
                        maxTilesX = 4200;
                        maxTilesY = 1200;
                    }
                    else if (selectedMenu == 2)
                    {
                        maxTilesX = 6400;
                        maxTilesY = 1800;
                    }
                    else
                    {
                        maxTilesX = 8400;
                        maxTilesY = 8400;
                    }
                    clrInput();
                    menuMode = -7;
                    SoundEngine.PlaySound(10);
                    WorldGen.setWorldSize();
                }
            }
            else if (menuMode == 1000000)
            {
                num5 = 2;
                array9[0] = statusText;
                array[0] = true;
                num2 = 220;
                num4 = 250;
                array9[1] = Lang.menu[5].Value;
                if (selectedMenu == 1 || flag5)
                {
                    flag5 = false;
                    SoundEngine.PlaySound(11);
                    menuMode = 6;
                    netMode = 0;
                }
            }
            else if (menuMode == 1000001)
            {
                num5 = 2;
                array9[0] = statusText;
                array[0] = true;
                num2 = 220;
                num4 = 250;
                RejectionMenuInfo rejectionMenuInfo = RejectionMenuInfo;
                if (rejectionMenuInfo != null)
                {
                    array9[0] = rejectionMenuInfo.TextToShow;
                }
                array9[1] = Lang.menu[5].Value;
                if (selectedMenu == 1 || flag5)
                {
                    flag5 = false;
                    ReturnFromRejectionMenuAction returnFromRejectionMenuAction = null;
                    if (RejectionMenuInfo != null)
                    {
                        returnFromRejectionMenuAction = RejectionMenuInfo.ExitAction;
                    }
                    if (returnFromRejectionMenuAction != null)
                    {
                        returnFromRejectionMenuAction();
                    }
                    else
                    {
                        SoundEngine.PlaySound(11);
                        menuMode = 0;
                        netMode = 0;
                    }
                }
            }
        }
        if (menuMode == 888)
        {
            if (!_blockFancyUIWhileLoading)
            {
                MenuUI.Draw(spriteBatch, gameTime);
            }
        }
        else
        {
            MenuUI.SetState(null);
        }
        if (UILinkPointNavigator.Shortcuts.BackButtonInUse && !flag5)
        {
            UILinkPointNavigator.Shortcuts.BackButtonLock = true;
        }
        int num47 = focusMenu;
        if (menuMode != num6)
        {
            if (menuMode == 10 || netMode == 1 || menuMode == 14)
            {
                gameTips.ClearTips();
            }
            blockMouse = true;
            menuSkip = 0;
            num5 = 0;
            if (PlayerInput.UsingGamepad && InvisibleCursorForGamepad)
            {
                num47 = (focusMenu = -1);
                mouseX = (mouseY = (PlayerInput.MouseX = (PlayerInput.MouseY = 0)));
            }
            for (int num48 = 0; num48 < maxMenuItems; num48++)
            {
                menuItemScale[num48] = 0.8f;
            }
        }
        if (!mouseLeft)
        {
            blockMouse = true;
        }
        selectedMenu = -1;
        selectedMenu2 = -1;
        focusMenu = -1;
        bool flag8 = mouseLeft && !PlayerInput.UsingGamepad;
        if (!flag)
        {
            grabColorSlider = 0;
            hBar = -1f;
            sBar = -1f;
            lBar = -1f;
            aBar = -1f;
        }
        if (flag)
        {
            if (!mouseLeft)
            {
                grabColorSlider = 0;
                blockMouse = false;
            }
            int num49 = focusColor;
            focusColor = 0;
            int num50 = num9;
            int num51 = screenWidth / 2 - TextureAssets.Hue.Width() / 2;
            int num52 = 167;
            Vector3 vector = rgbToHsl(selColor);
            float num53 = vector.X;
            float num54 = vector.Y;
            float luminosity = vector.Z;
            float num55 = (float)(int)selColor.A / 255f;
            if (hBar == -1f || sBar == -1f || lBar == -1f || aBar == -1f)
            {
                hBar = num53;
                sBar = num54;
                lBar = luminosity;
                aBar = num55;
            }
            else
            {
                num53 = hBar;
                num54 = sBar;
                luminosity = lBar;
                num55 = aBar;
            }
            spriteBatch.Draw(TextureAssets.Hue.Value, new Vector2(num51, num50), Microsoft.Xna.Framework.Color.White);
            if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 1)
            {
                spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num51, num50), OurFavoriteColor);
            }
            spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num51 + (float)(TextureAssets.Hue.Width() - 2) * hBar - (float)(TextureAssets.ColorSlider.Width() / 2), num50 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
            if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 1)
            {
                focusColor = 1;
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 5;
                if (flag8 && !blockMouse)
                {
                    grabColorSlider = 1;
                    num53 = mouseX - num51;
                    num53 /= (float)TextureAssets.Hue.Width();
                    if (num53 < 0f)
                    {
                        num53 = 0f;
                    }
                    if (num53 > 1f)
                    {
                        num53 = 1f;
                    }
                    hBar = num53;
                }
            }
            GamepadMainMenuHandler.MenuItemPositions.Add(new Vector2(num51, num50) + TextureAssets.ColorBar.Value.Size() / 2f);
            num50 += 26;
            spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num51, num50), Microsoft.Xna.Framework.Color.White);
            for (int num56 = 0; num56 <= num52; num56++)
            {
                float saturation = (float)num56 / (float)num52;
                Microsoft.Xna.Framework.Color color4 = hslToRgb(num53, saturation, luminosity);
                spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num51 + num56 + 5, num50 + 4), color4);
            }
            if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 2)
            {
                spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num51, num50), OurFavoriteColor);
            }
            spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num51 + (float)(TextureAssets.Hue.Width() - 2) * sBar - (float)(TextureAssets.ColorSlider.Width() / 2), num50 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
            if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 2)
            {
                focusColor = 2;
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 6;
                if (flag8 && !blockMouse)
                {
                    grabColorSlider = 2;
                    num54 = mouseX - num51;
                    num54 /= (float)TextureAssets.Hue.Width();
                    if (num54 < 0f)
                    {
                        num54 = 0f;
                    }
                    if (num54 > 1f)
                    {
                        num54 = 1f;
                    }
                    sBar = num54;
                }
            }
            GamepadMainMenuHandler.MenuItemPositions.Add(new Vector2(num51, num50) + TextureAssets.ColorBar.Value.Size() / 2f);
            num50 += 26;
            spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num51, num50), Microsoft.Xna.Framework.Color.White);
            float num57 = 0.15f;
            if (menuMode == 252)
            {
                num57 = 0f;
            }
            for (int num58 = 0; num58 <= num52; num58++)
            {
                float luminosity2 = (float)num58 / (float)num52;
                Microsoft.Xna.Framework.Color color5 = hslToRgb(num53, num54, luminosity2);
                spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num51 + num58 + 5, num50 + 4), color5);
            }
            if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 3)
            {
                spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num51, num50), OurFavoriteColor);
            }
            spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num51 + (float)(TextureAssets.Hue.Width() - 2) * ((lBar - num57) / (1f - num57)) - (float)(TextureAssets.ColorSlider.Width() / 2), num50 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
            if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 3)
            {
                focusColor = 3;
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 7;
                if (flag8 && !blockMouse)
                {
                    grabColorSlider = 3;
                    luminosity = mouseX - num51;
                    luminosity /= (float)TextureAssets.Hue.Width();
                    if (luminosity < 0f)
                    {
                        luminosity = 0f;
                    }
                    if (luminosity > 1f)
                    {
                        luminosity = 1f;
                    }
                    luminosity = (lBar = luminosity * (1f - num57) + num57);
                }
            }
            GamepadMainMenuHandler.MenuItemPositions.Add(new Vector2(num51, num50) + TextureAssets.ColorBar.Value.Size() / 2f);
            bool flag9 = false;
            if (menuMode == 252)
            {
                num50 += 26;
                flag9 = true;
                spriteBatch.Draw(TextureAssets.ColorBar.Value, new Vector2(num51, num50), Microsoft.Xna.Framework.Color.White);
                Microsoft.Xna.Framework.Color color6 = hslToRgb(num53, num54, luminosity);
                for (int num59 = 0; num59 <= num52; num59++)
                {
                    float num60 = (float)num59 / (float)num52;
                    Microsoft.Xna.Framework.Color color7 = color6 * num60;
                    spriteBatch.Draw(TextureAssets.ColorBlip.Value, new Vector2(num51 + num59 + 5, num50 + 4), color7);
                }
                if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 4)
                {
                    spriteBatch.Draw(TextureAssets.ColorHighlight.Value, new Vector2(num51, num50), OurFavoriteColor);
                }
                spriteBatch.Draw(TextureAssets.ColorSlider.Value, new Vector2((float)num51 + (float)(TextureAssets.Hue.Width() - 2) * aBar - (float)(TextureAssets.ColorSlider.Width() / 2), num50 - TextureAssets.ColorSlider.Height() / 2 + TextureAssets.Hue.Height() / 2), Microsoft.Xna.Framework.Color.White);
                if ((mouseX > num51 - 4 && mouseX < num51 + TextureAssets.Hue.Width() + 4 && mouseY > num50 - 4 && mouseY < num50 + TextureAssets.Hue.Height() + 4 && grabColorSlider == 0) || grabColorSlider == 4)
                {
                    focusColor = 4;
                    UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 8;
                    if (mouseLeft && !blockMouse)
                    {
                        grabColorSlider = 4;
                        num55 = mouseX - num51;
                        num55 /= (float)TextureAssets.Hue.Width();
                        if (num55 < 0f)
                        {
                            num55 = 0f;
                        }
                        if (num55 > 1f)
                        {
                            num55 = 1f;
                        }
                        aBar = num55;
                    }
                }
                GamepadMainMenuHandler.MenuItemPositions.Add(new Vector2(num51, num50) + TextureAssets.ColorBar.Value.Size() / 2f);
            }
            if (num49 != focusColor)
            {
                SoundEngine.PlaySound(12);
            }
            selColor = hslToRgb(hBar, sBar, lBar);
            if (flag9)
            {
                selColor.A = (byte)(aBar * 255f);
            }
        }
        else if (flag)
        {
            string text5 = "";
            for (int num61 = 0; num61 < 6; num61++)
            {
                int num62 = num9;
                int num63 = 370 + screenWidth / 2 - 400;
                if (num61 == 0)
                {
                    text5 = Lang.menu[95].Value;
                }
                if (num61 == 1)
                {
                    text5 = Lang.menu[96].Value;
                    num62 += 30;
                }
                if (num61 == 2)
                {
                    text5 = Lang.menu[97].Value;
                    num62 += 60;
                }
                if (num61 == 3)
                {
                    text5 = string.Concat(selColor.R);
                    num63 += 90;
                }
                if (num61 == 4)
                {
                    text5 = string.Concat(selColor.G);
                    num63 += 90;
                    num62 += 30;
                }
                if (num61 == 5)
                {
                    text5 = string.Concat(selColor.B);
                    num63 += 90;
                    num62 += 60;
                }
                for (int num64 = 0; num64 < 5; num64++)
                {
                    Microsoft.Xna.Framework.Color color8 = Microsoft.Xna.Framework.Color.Black;
                    if (num64 == 4)
                    {
                        color8 = color;
                        color8.R = (byte)((255 + color8.R) / 2);
                        color8.G = (byte)((255 + color8.R) / 2);
                        color8.B = (byte)((255 + color8.R) / 2);
                    }
                    int num65 = 255;
                    int num66 = color8.R - (255 - num65);
                    if (num66 < 0)
                    {
                        num66 = 0;
                    }
                    color8 = new Microsoft.Xna.Framework.Color((byte)num66, (byte)num66, (byte)num66, (byte)num65);
                    int num67 = 0;
                    int num68 = 0;
                    if (num64 == 0)
                    {
                        num67 = -2;
                    }
                    if (num64 == 1)
                    {
                        num67 = 2;
                    }
                    if (num64 == 2)
                    {
                        num68 = -2;
                    }
                    if (num64 == 3)
                    {
                        num68 = 2;
                    }
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, text5, new Vector2(num63 + num67, num62 + num68), color8, 0f, default(Vector2), 0.5f, SpriteEffects.None, 0f);
                }
            }
            bool flag10 = false;
            for (int num69 = 0; num69 < 2; num69++)
            {
                for (int num70 = 0; num70 < 3; num70++)
                {
                    int num71 = num9 + num70 * 30 - 12;
                    int num72 = 360 + screenWidth / 2 - 400;
                    float num73 = 0.9f;
                    if (num69 == 0)
                    {
                        num72 -= 70;
                        num71 += 2;
                    }
                    else
                    {
                        num72 -= 40;
                    }
                    text5 = "-";
                    if (num69 == 1)
                    {
                        text5 = "+";
                    }
                    Vector2 vector2 = new Vector2(24f, 24f);
                    int num74 = 142;
                    if (mouseX > num72 && (float)mouseX < (float)num72 + vector2.X && mouseY > num71 + 13 && (float)mouseY < (float)(num71 + 13) + vector2.Y)
                    {
                        if (focusColor != (num69 + 1) * (num70 + 10))
                        {
                            SoundEngine.PlaySound(12);
                        }
                        focusColor = (num69 + 1) * (num70 + 10);
                        flag10 = true;
                        num74 = 255;
                        if (mouseLeft)
                        {
                            if (colorDelay <= 1)
                            {
                                if (colorDelay == 0)
                                {
                                    colorDelay = 40;
                                }
                                else
                                {
                                    colorDelay = 3;
                                }
                                int num75 = num69;
                                if (num69 == 0)
                                {
                                    num75 = -1;
                                    if (selColor.R + selColor.G + selColor.B <= 150)
                                    {
                                        num75 = 0;
                                    }
                                }
                                if (num70 == 0 && selColor.R + num75 >= 0 && selColor.R + num75 <= 255)
                                {
                                    selColor.R = (byte)(selColor.R + num75);
                                }
                                if (num70 == 1 && selColor.G + num75 >= 0 && selColor.G + num75 <= 255)
                                {
                                    selColor.G = (byte)(selColor.G + num75);
                                }
                                if (num70 == 2 && selColor.B + num75 >= 0 && selColor.B + num75 <= 255)
                                {
                                    selColor.B = (byte)(selColor.B + num75);
                                }
                            }
                            colorDelay--;
                        }
                        else
                        {
                            colorDelay = 0;
                        }
                    }
                    for (int num76 = 0; num76 < 5; num76++)
                    {
                        Microsoft.Xna.Framework.Color color9 = Microsoft.Xna.Framework.Color.Black;
                        if (num76 == 4)
                        {
                            color9 = color;
                            color9.R = (byte)((255 + color9.R) / 2);
                            color9.G = (byte)((255 + color9.R) / 2);
                            color9.B = (byte)((255 + color9.R) / 2);
                        }
                        int num77 = color9.R - (255 - num74);
                        if (num77 < 0)
                        {
                            num77 = 0;
                        }
                        color9 = new Microsoft.Xna.Framework.Color((byte)num77, (byte)num77, (byte)num77, (byte)num74);
                        int num78 = 0;
                        int num79 = 0;
                        if (num76 == 0)
                        {
                            num78 = -2;
                        }
                        if (num76 == 1)
                        {
                            num78 = 2;
                        }
                        if (num76 == 2)
                        {
                            num79 = -2;
                        }
                        if (num76 == 3)
                        {
                            num79 = 2;
                        }
                        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, text5, new Vector2(num72 + num78, num71 + num79), color9, 0f, default(Vector2), num73, SpriteEffects.None, 0f);
                    }
                }
            }
            if (!flag10)
            {
                focusColor = 0;
                colorDelay = 0;
            }
        }
        if (flag2)
        {
            float x = screenWidth / 2 - 40 + 37;
            int num80 = 320;
            string text6 = "";
            for (int num81 = 0; num81 < 6; num81++)
            {
                int num82 = num80;
                int num83 = 370 + screenWidth / 2 - 400 + 37;
                switch (num81)
                {
                case 0:
                    text6 = Lang.menu[98].Value;
                    num82 += 30;
                    break;
                case 1:
                    text6 = Lang.menu[99].Value;
                    break;
                case 2:
                    text6 = Lang.menu[119].Value;
                    num82 += 60;
                    break;
                case 3:
                    text6 = Math.Round(musicVolume * 100f) + "%";
                    num83 += 90;
                    break;
                case 4:
                    text6 = Math.Round(soundVolume * 100f) + "%";
                    num83 += 90;
                    num82 += 30;
                    break;
                case 5:
                    text6 = Math.Round(ambientVolume * 100f) + "%";
                    num83 += 90;
                    num82 += 60;
                    break;
                }
                Microsoft.Xna.Framework.Color color10 = color;
                color10.R = (byte)((255 + color10.R) / 2);
                color10.G = (byte)((255 + color10.R) / 2);
                color10.B = (byte)((255 + color10.R) / 2);
                int num84 = 255;
                int num85 = color10.R - (255 - num84);
                if (num85 < 0)
                {
                    num85 = 0;
                }
                Utils.DrawBorderStringFourWay(textColor: new Microsoft.Xna.Framework.Color((byte)num85, (byte)num85, (byte)num85, (byte)num84), sb: spriteBatch, font: FontAssets.DeathText.Value, text: text6, x: num83, y: num82, borderColor: Microsoft.Xna.Framework.Color.Black, origin: Vector2.Zero, scale: 0.5f);
            }
            int rightHover = IngameOptions.rightHover;
            IngameOptions.rightHover = -1;
            if (!mouseLeft)
            {
                IngameOptions.rightLock = -1;
            }
            IngameOptions.valuePosition = new Vector2(x, num80 - 18 + 30);
            GamepadMainMenuHandler.MenuItemPositions.Add(IngameOptions.valuePosition - TextureAssets.ColorBar.Value.Size() * new Vector2(0.5f, 0f));
            float num86 = IngameOptions.DrawValueBar(spriteBatch, 1f, musicVolume);
            if (IngameOptions.inBar || IngameOptions.rightLock == 3)
            {
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 2;
                IngameOptions.rightHover = 3;
                if (flag8 && IngameOptions.rightLock == 3)
                {
                    musicVolume = num86;
                }
            }
            IngameOptions.valuePosition = new Vector2(x, num80 - 18 + 60);
            GamepadMainMenuHandler.MenuItemPositions.Add(IngameOptions.valuePosition - TextureAssets.ColorBar.Value.Size() * new Vector2(0.5f, 0f));
            float num87 = IngameOptions.DrawValueBar(spriteBatch, 1f, soundVolume);
            if (IngameOptions.inBar || IngameOptions.rightLock == 2)
            {
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 3;
                IngameOptions.rightHover = 2;
                if (flag8 && IngameOptions.rightLock == 2)
                {
                    soundVolume = num87;
                }
            }
            IngameOptions.valuePosition = new Vector2(x, num80 - 18 + 90);
            GamepadMainMenuHandler.MenuItemPositions.Add(IngameOptions.valuePosition - TextureAssets.ColorBar.Value.Size() * new Vector2(0.5f, 0f));
            float num88 = IngameOptions.DrawValueBar(spriteBatch, 1f, ambientVolume);
            if (IngameOptions.inBar || IngameOptions.rightLock == 4)
            {
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 4;
                IngameOptions.rightHover = 4;
                if (flag8 && IngameOptions.rightLock == 4)
                {
                    ambientVolume = num88;
                }
            }
            if (IngameOptions.rightHover != -1)
            {
                IngameOptions.rightLock = IngameOptions.rightHover;
            }
            if (IngameOptions.rightHover != rightHover)
            {
                SoundEngine.PlaySound(12);
            }
        }
        if (flag3)
        {
            int num89 = 400;
            string text7 = "";
            for (int num90 = 0; num90 < 4; num90++)
            {
                int num91 = num89;
                int num92 = 370 + screenWidth / 2 - 400;
                if (num90 == 0)
                {
                    text7 = Lang.menu[52].Value + ": " + bgScroll;
                }
                for (int num93 = 0; num93 < 5; num93++)
                {
                    Microsoft.Xna.Framework.Color color11 = Microsoft.Xna.Framework.Color.Black;
                    if (num93 == 4)
                    {
                        color11 = color;
                        color11.R = (byte)((255 + color11.R) / 2);
                        color11.G = (byte)((255 + color11.R) / 2);
                        color11.B = (byte)((255 + color11.R) / 2);
                    }
                    int num94 = 255;
                    int num95 = color11.R - (255 - num94);
                    if (num95 < 0)
                    {
                        num95 = 0;
                    }
                    color11 = new Microsoft.Xna.Framework.Color((byte)num95, (byte)num95, (byte)num95, (byte)num94);
                    int num96 = 0;
                    int num97 = 0;
                    if (num93 == 0)
                    {
                        num96 = -2;
                    }
                    if (num93 == 1)
                    {
                        num96 = 2;
                    }
                    if (num93 == 2)
                    {
                        num97 = -2;
                    }
                    if (num93 == 3)
                    {
                        num97 = 2;
                    }
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, text7, new Vector2(num92 + num96, num91 + num97), color11, 0f, default(Vector2), 0.5f, SpriteEffects.None, 0f);
                }
            }
            IngameOptions.rightHover = -1;
            if (!mouseLeft)
            {
                IngameOptions.rightLock = -1;
            }
            IngameOptions.valuePosition = new Vector2(screenWidth / 2 - 40, num89 + 12);
            GamepadMainMenuHandler.MenuItemPositions.Add(IngameOptions.valuePosition - TextureAssets.ColorBar.Value.Size() * new Vector2(0.5f, 0f));
            float num98 = IngameOptions.DrawValueBar(spriteBatch, 1f, (float)bgScroll / 100f);
            if (IngameOptions.inBar || IngameOptions.rightLock == 2)
            {
                UILinkPointNavigator.Shortcuts.OPTIONS_BUTTON_SPECIALFEATURE = 1;
                IngameOptions.rightHover = 2;
                if (flag8 && IngameOptions.rightLock == 2)
                {
                    bgScroll = (int)(num98 * 100f);
                    caveParallax = 1f - (float)bgScroll / 500f;
                }
            }
            if (IngameOptions.rightHover != -1)
            {
                IngameOptions.rightLock = IngameOptions.rightHover;
            }
        }
        bool flag11 = false;
        for (int num99 = 0; num99 < num5; num99++)
        {
            if (array9[num99] == null)
            {
                continue;
            }
            Vector2 vector3 = FontAssets.DeathText.Value.MeasureString(array9[num99]);
            vector3.X *= 0.5f;
            vector3.Y *= 0.5f;
            for (int num100 = 0; num100 < 5; num100++)
            {
                Microsoft.Xna.Framework.Color color12 = Microsoft.Xna.Framework.Color.Black;
                if (num100 == 4)
                {
                    switch (array6[num99])
                    {
                    case 0:
                        color12 = color;
                        break;
                    case 1:
                        color12 = mcColor;
                        break;
                    case 2:
                        color12 = hcColor;
                        break;
                    case 3:
                        color12 = highVersionColor;
                        break;
                    case 4:
                    case 5:
                    case 6:
                        color12 = errorColor;
                        break;
                    default:
                        color12 = color;
                        break;
                    }
                    color12.R = (byte)((255 + color12.R) / 2);
                    color12.G = (byte)((255 + color12.G) / 2);
                    color12.B = (byte)((255 + color12.B) / 2);
                }
                int num101 = (int)(255f * (menuItemScale[num99] * 2f - 1f));
                if (array[num99])
                {
                    num101 = 255;
                }
                int num102 = color12.R - (255 - num101);
                if (num102 < 0)
                {
                    num102 = 0;
                }
                int num103 = color12.G - (255 - num101);
                if (num103 < 0)
                {
                    num103 = 0;
                }
                int num104 = color12.B - (255 - num101);
                if (num104 < 0)
                {
                    num104 = 0;
                }
                if (num47 == num99 && num100 == 4)
                {
                    float num105 = (float)num101 / 255f;
                    num102 = (int)((float)num102 * (1f - num105) + 255f * num105);
                    num103 = (int)((float)num103 * (1f - num105) + 215f * num105);
                    num104 = (int)((float)num104 * (1f - num105) + 0f * num105);
                }
                color12 = new Microsoft.Xna.Framework.Color((byte)num102, (byte)num103, (byte)num104, (byte)num101);
                if (array3[num99])
                {
                    if (num100 == 4)
                    {
                        color12.R = (byte)(color12.R * mouseTextColor / 300);
                        color12.G = (byte)(color12.G * mouseTextColor / 300);
                        color12.B = (byte)(color12.B * mouseTextColor / 300);
                        color12.A = (byte)(color12.A * mouseTextColor / 300);
                    }
                    else
                    {
                        color12.A -= (byte)(mouseTextColor / 5);
                    }
                }
                int num106 = 0;
                int num107 = 0;
                if (num100 == 0)
                {
                    num106 = -2;
                }
                if (num100 == 1)
                {
                    num106 = 2;
                }
                if (num100 == 2)
                {
                    num107 = -2;
                }
                if (num100 == 3)
                {
                    num107 = 2;
                }
                float num108 = menuItemScale[num99];
                if (menuMode == 15 && num99 == 0)
                {
                    num108 *= 0.35f;
                }
                else if (menuMode == 1000000 && num99 == 0)
                {
                    num108 *= 0.75f;
                }
                else if (netMode == 2)
                {
                    num108 *= 0.5f;
                }
                num108 *= array7[num99];
                if (!array8[num99])
                {
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, array9[num99], new Vector2(num3 + num106 + array5[num99], (float)(num2 + num4 * num99 + num107) + vector3.Y * array7[num99] + (float)array4[num99]), color12, 0f, vector3, num108, SpriteEffects.None, 0f);
                }
                else
                {
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.DeathText.Value, array9[num99], new Vector2(num3 + num106 + array5[num99], (float)(num2 + num4 * num99 + num107) + vector3.Y * array7[num99] + (float)array4[num99]), color12, 0f, new Vector2(0f, vector3.Y), num108, SpriteEffects.None, 0f);
                }
            }
            if (!array[num99] && !array2[num99])
            {
                GamepadMainMenuHandler.MenuItemPositions.Add(new Vector2(num3 + array5[num99], (float)(num2 + num4 * num99) + vector3.Y * array7[num99] + (float)array4[num99]));
            }
            if (!array8[num99])
            {
                int num109 = 0;
                menuWide[num99] = false;
                Vector2 vector4 = FontAssets.DeathText.Value.MeasureString(array9[num99]) * array7[num99];
                if (!((float)mouseX > (float)num3 - vector4.X * 0.5f + (float)array5[num99] - (float)num109) || !((float)mouseX < (float)num3 + vector4.X * 0.5f * array7[num99] + (float)array5[num99] + (float)num109) || mouseY <= num2 + num4 * num99 + array4[num99] || !((float)mouseY < (float)(num2 + num4 * num99 + array4[num99]) + 50f * array7[num99]) || !hasFocus)
                {
                    continue;
                }
                focusMenu = num99;
                if (array[num99] || array2[num99])
                {
                    focusMenu = -1;
                    continue;
                }
                if (num47 != focusMenu)
                {
                    flag11 = true;
                }
                if (mouseLeftRelease && mouseLeft)
                {
                    selectedMenu = num99;
                }
                if (mouseRightRelease && mouseRight)
                {
                    selectedMenu2 = num99;
                }
                continue;
            }
            Vector2 vector5 = FontAssets.DeathText.Value.MeasureString(array9[num99]) * array7[num99];
            if (mouseX <= num3 + array5[num99] || !((float)mouseX < (float)num3 + vector5.X + (float)array5[num99]) || mouseY <= num2 + num4 * num99 + array4[num99] || !((float)mouseY < (float)(num2 + num4 * num99 + array4[num99]) + 50f * array7[num99]) || !hasFocus)
            {
                continue;
            }
            focusMenu = num99;
            if (array[num99] || array2[num99])
            {
                focusMenu = -1;
                continue;
            }
            if (num47 != focusMenu)
            {
                flag11 = true;
            }
            if (mouseLeftRelease && mouseLeft)
            {
                selectedMenu = num99;
            }
            if (mouseRightRelease && mouseRight)
            {
                selectedMenu2 = num99;
            }
        }
        if (flag11 && num47 != focusMenu)
        {
            SoundEngine.PlaySound(12);
        }
        if (GamepadMainMenuHandler.MenuItemPositions.Count == 0)
        {
            Vector2 vector6 = new Vector2((float)Math.Cos(GlobalTimeWrappedHourly * ((float)Math.PI * 2f)), (float)Math.Sin(GlobalTimeWrappedHourly * ((float)Math.PI * 2f) * 2f)) * new Vector2(30f, 15f) + Vector2.UnitY * 20f;
            UILinkPointNavigator.SetPosition(2000, new Vector2(screenWidth, screenHeight) / 2f + vector6);
        }
        for (int num110 = 0; num110 < maxMenuItems; num110++)
        {
            if (num110 == focusMenu)
            {
                if (menuItemScale[num110] < 1f)
                {
                    menuItemScale[num110] += 0.02f;
                }
                if (menuItemScale[num110] > 1f)
                {
                    menuItemScale[num110] = 1f;
                }
            }
            else if ((double)menuItemScale[num110] > 0.8)
            {
                menuItemScale[num110] -= 0.02f;
            }
        }
        if (flag4)
        {
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
            Player pendingPlayer = PendingPlayer;
            pendingPlayer.PlayerFrame();
            pendingPlayer.position.X = (float)num7 + screenPosition.X;
            pendingPlayer.position.Y = (float)num8 + screenPosition.Y;
            PlayerRenderer.DrawPlayer(Camera, pendingPlayer, pendingPlayer.position, 0f, Vector2.Zero);
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
        }
        float num111 = 0f;
        if (!WorldGen.drunkWorldGen && menuMode == 0)
        {
            DrawSocialMediaButtons(color, num111);
            num111 += 32f;
        }
        if (!WorldGen.drunkWorldGen)
        {
            DrawVersionNumber(color, num111);
            num111 += 20f;
        }
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerStateForCursor, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
        WorkshopPublishingIndicator.Draw(spriteBatch);
        IssueReporterIndicator.Draw(spriteBatch);
        DrawCursor(DrawThickCursor());
        DrawPendingMouseText();
        if (fadeCounter > 0)
        {
            Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
            byte b2 = 0;
            fadeCounter--;
            float num112 = (float)fadeCounter / 120f * 255f;
            if (quickSplash)
            {
                num112 = (float)fadeCounter / 75f * 255f;
            }
            b2 = (byte)num112;
            white = new Microsoft.Xna.Framework.Color(b2, b2, b2, b2);
            spriteBatch.Draw(TextureAssets.Fade.Value, new Microsoft.Xna.Framework.Rectangle(-5, -5, screenWidth + 10, screenHeight + 10), white);
        }
        spriteBatch.End();
        if (mouseLeft)
        {
            mouseLeftRelease = false;
        }
        else
        {
            mouseLeftRelease = true;
        }
        if (mouseRight)
        {
            mouseRightRelease = false;
        }
        else
        {
            mouseRightRelease = true;
        }
        if (menuMode == num)
        {
            GamepadMainMenuHandler.LastDrew = num;
        }
    }
 
    public static void CycleFrameSkipMode()
    {
        int frameSkipMode = (int)FrameSkipMode;
        frameSkipMode++;
        if (frameSkipMode < 0 || frameSkipMode > 2)
        {
            frameSkipMode = 0;
        }
        FrameSkipMode = (FrameSkipMode)frameSkipMode;
    }
 
    private static void OnSubmitServerPasswordFromRequest(string passwordCandidate)
    {
        Netplay.ServerPassword = passwordCandidate;
        OnSubmitServerPasswordFromRequest();
    }
 
    private static void OnSubmitServerPasswordFromRequest()
    {
        NetMessage.SendData(38);
        menuMode = 14;
    }
 
    private static void CanceledGivingServerPassword()
    {
        SoundEngine.PlaySound(11);
        menuMode = 0;
        Netplay.Disconnect = true;
        Netplay.ServerPassword = "";
    }
 
    private void OnSubmitServerPassword(string passwordCandidate)
    {
        Netplay.ServerPassword = passwordCandidate;
        OnSubmitServerPassword();
    }
 
    private void OnSubmitServerPassword()
    {
        string text = "-autoshutdown -password \"" + ConvertToSafeArgument(Netplay.ServerPassword) + "\" -lang " + Language.ActiveCulture.LegacyId;
        if (Platform.IsLinux)
        {
            text = ((IntPtr.Size != 8) ? (text + " -x86") : (text + " -x64"));
        }
        text = ((!ActiveWorldFileData.IsCloudSave) ? (text + SanitizePathArgument("world", worldPathName)) : (text + SanitizePathArgument("cloudworld", worldPathName)));
        text = text + " -worldrollbackstokeep " + WorldRollingBackupsCountToKeep;
        tServer = new Process();
        if (Platform.IsLinux)
        {
            tServer.StartInfo.FileName = "TerrariaServer";
        }
        else if (Platform.IsOSX)
        {
            tServer.StartInfo.FileName = "../MacOS/TerrariaServer";
        }
        else
        {
            tServer.StartInfo.FileName = "TerrariaServer.exe";
        }
        tServer.StartInfo.Arguments = text;
        if (libPath != "")
        {
            ProcessStartInfo startInfo = tServer.StartInfo;
            startInfo.Arguments = startInfo.Arguments + " -loadlib " + libPath;
        }
        tServer.StartInfo.UseShellExecute = false;
        tServer.StartInfo.CreateNoWindow = true;
        if (SocialAPI.Network != null)
        {
            SocialAPI.Network.LaunchLocalServer(tServer, MenuServerMode);
        }
        else
        {
            tServer.Start();
        }
        Netplay.SetRemoteIP("127.0.0.1");
        autoPass = true;
        statusText = Lang.menu[8].Value;
        Netplay.StartTcpClient();
        menuMode = 10;
    }
 
    private static void ExitServerPasswordMenu()
    {
        if (SocialAPI.Network != null)
        {
            menuMode = 889;
        }
        else
        {
            menuMode = 6;
        }
        Netplay.ServerPassword = "";
    }
 
    private static bool IsGoodPortAddress(string text)
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            return false;
        }
        ushort result = 0;
        if (!ushort.TryParse(text, out result))
        {
            return false;
        }
        return true;
    }
 
    private static void OnSubmitServerPort(string candidatePort)
    {
        Netplay.ListenPort = ushort.Parse(candidatePort);
        autoPass = false;
        Netplay.SetRemoteIPAsync(getIP, StartClientGameplay);
        menuMode = 14;
        statusText = Language.GetTextValue("Net.ConnectingTo", getIP);
    }
 
    public static void OnSubmitServerIP(string inputText)
    {
        getIP = inputText;
        SoundEngine.PlaySound(12);
        menuMode = 131;
        clrInput();
    }
 
    private static void DrawSocialMediaButtons(Microsoft.Xna.Framework.Color menuColor, float upBump)
    {
        List<TitleLinkButton> titleLinks = TitleLinks;
        Vector2 anchorPosition = new Vector2(18f, (float)(screenHeight - 26) - upBump);
        for (int i = 0; i < titleLinks.Count; i++)
        {
            titleLinks[i].Draw(spriteBatch, anchorPosition);
            anchorPosition.X += 30f;
        }
    }
 
    private static void DrawVersionNumber(Microsoft.Xna.Framework.Color menuColor, float upBump)
    {
        string text = versionNumber;
        Vector2 vector = FontAssets.MouseText.Value.MeasureString(text);
        vector.X *= 0.5f;
        vector.Y *= 0.5f;
        for (int i = 0; i < 5; i++)
        {
            Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Black;
            if (i == 4)
            {
                color = menuColor;
                color.R = (byte)((255 + color.R) / 2);
                color.G = (byte)((255 + color.R) / 2);
                color.B = (byte)((255 + color.R) / 2);
            }
            color.A = (byte)((float)(int)color.A * 0.3f);
            int num = 0;
            int num2 = 0;
            if (i == 0)
            {
                num = -2;
            }
            if (i == 1)
            {
                num = 2;
            }
            if (i == 2)
            {
                num2 = -2;
            }
            if (i == 3)
            {
                num2 = 2;
            }
            DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(vector.X + (float)num + 10f, (float)screenHeight - vector.Y + (float)num2 - 2f - upBump), color, 0f, vector, 1f, SpriteEffects.None, 0f);
        }
    }
 
    private static void ClearVisualPostProcessEffects()
    {
        for (int i = 0; i < 13; i++)
        {
            string key = "";
            switch (i)
            {
            case 0:
                key = "Solar";
                break;
            case 1:
                key = "Vortex";
                break;
            case 2:
                key = "Nebula";
                break;
            case 3:
                key = "Stardust";
                break;
            case 4:
                key = "MoonLord";
                break;
            case 5:
                key = "MonolithSolar";
                break;
            case 6:
                key = "MonolithVortex";
                break;
            case 7:
                key = "MonolithNebula";
                break;
            case 8:
                key = "MonolithStardust";
                break;
            case 9:
                key = "Blizzard";
                break;
            case 10:
                key = "HeatDistortion";
                break;
            case 11:
                key = "Sandstorm";
                break;
            case 12:
                key = "MonolithMoonLord";
                break;
            }
            if (SkyManager.Instance[key] != null && SkyManager.Instance[key].IsActive())
            {
                SkyManager.Instance[key].Deactivate();
            }
            if (Overlays.Scene[key] != null && Overlays.Scene[key].IsVisible())
            {
                Overlays.Scene[key].Deactivate();
            }
            if (Terraria.Graphics.Effects.Filters.Scene[key] != null && Terraria.Graphics.Effects.Filters.Scene[key].IsActive())
            {
                Terraria.Graphics.Effects.Filters.Scene[key].Deactivate();
            }
        }
        if (Terraria.Graphics.Effects.Filters.Scene["BloodMoon"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene["BloodMoon"].Deactivate();
        }
        if (Terraria.Graphics.Effects.Filters.Scene["Graveyard"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene["Graveyard"].Deactivate();
        }
        if (Terraria.Graphics.Effects.Filters.Scene["Sepia"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene["Sepia"].Deactivate();
        }
        if (Terraria.Graphics.Effects.Filters.Scene["BloodMoon"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene["BloodMoon"].Deactivate();
        }
        if (Terraria.Graphics.Effects.Filters.Scene["MoonLordShake"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene["MoonLordShake"].Deactivate();
        }
        if (Terraria.Graphics.Effects.Filters.Scene["WaterDistortion"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene["WaterDistortion"].Deactivate();
        }
        if (SkyManager.Instance["Martian"].IsActive())
        {
            SkyManager.Instance["Martian"].Deactivate();
        }
        if (SkyManager.Instance["Party"].IsActive())
        {
            SkyManager.Instance["Party"].Deactivate();
        }
        if (SkyManager.Instance["Slime"].IsActive())
        {
            SkyManager.Instance["Slime"].Deactivate();
        }
        if (SkyManager.Instance["Ambience"].IsActive())
        {
            SkyManager.Instance["Ambience"].Deactivate();
        }
        slimeRain = false;
        slimeRainTime = 0.0;
        slimeWarningTime = 0;
        BirthdayParty.WorldClear();
        LanternNight.WorldClear();
        Sandstorm.WorldClear();
        CreditsRollEvent.Reset();
        maxRaining = 0f;
        raining = false;
    }
 
    private static void PostDrawMenu(Microsoft.Xna.Framework.Point screenSizeCache, Microsoft.Xna.Framework.Point screenSizeCacheAfterScaling)
    {
        if (ScreenSize == screenSizeCacheAfterScaling)
        {
            screenPosition.Y -= screenSizeCache.Y - screenHeight;
        }
    }
 
    private void PreDrawMenu(out Microsoft.Xna.Framework.Point screenSizeCache, out Microsoft.Xna.Framework.Point screenSizeCacheAfterScaling)
    {
        float uiScaleWanted = _uiScaleWanted;
        float num = (float)screenHeight / 900f;
        if (num < 1f)
        {
            num = 1f;
        }
        if (SettingDontScaleMainMenuUp)
        {
            num = 1f;
        }
        screenSizeCache = ScreenSize;
        UIScale = num;
        PlayerInput.SetZoom_UI();
        screenSizeCacheAfterScaling = ScreenSize;
        if (_needsMenuUIRecalculation)
        {
            _needsMenuUIRecalculation = false;
            MenuUI.Recalculate();
        }
        _uiScaleWanted = uiScaleWanted;
    }
 
    private static bool IsBorderlessDisplayAvailable()
    {
        bool result = false;
        if (Platform.IsWindows)
        {
            result = true;
        }
        return result;
    }
 
    private static void SetDisplayModeAsBorderless(ref int width, ref int height, Form form)
    {
        if (screenBorderless && !graphics.IsFullScreen && screenBorderlessPendingResizes > 0)
        {
            screenBorderlessPendingResizes--;
            System.Drawing.Rectangle bounds = Screen.FromPoint(form.Location).Bounds;
            width = bounds.Width;
            height = bounds.Height;
            TryPickingDefaultUIScale(height);
        }
    }
 
    private static void ApplyBorderlessResolution(Form form)
    {
        if (screenBorderlessPendingResizes > 0)
        {
            screenBorderlessPendingResizes--;
            System.Drawing.Rectangle bounds = Screen.FromPoint(form.Location).Bounds;
            form.Location = new System.Drawing.Point(bounds.X, bounds.Y);
            form.FormBorderStyle = FormBorderStyle.None;
            form.Width = bounds.Width;
            form.Height = bounds.Height;
        }
    }
 
    private static void SetBorderlessFormStyle(Form form)
    {
        form.Location = new System.Drawing.Point(0, 0);
        form.FormBorderStyle = FormBorderStyle.None;
    }
 
    public static void OpenCharacterSelectUI()
    {
        menuMode = 888;
        MenuUI.SetState(_characterSelectMenu);
    }
 
    public static void OpenReportsMenu()
    {
        List<IProvideReports> list = new List<IProvideReports>();
        list.Add(IssueReporter);
        if (SocialAPI.Workshop != null)
        {
            list.Add(SocialAPI.Workshop.IssueReporter);
        }
        UIReportsPage state = new UIReportsPage(MenuUI.CurrentState, menuMode, list);
        menuMode = 888;
        MenuUI.SetState(state);
    }
 
    public static void OpenWorldSelectUI()
    {
        menuMode = 888;
        MenuUI.SetState(_worldSelectMenu);
    }
 
    public static void OpenResourcePacksMenu(UIState uiStateToGoBackTo)
    {
        menuMode = 888;
        MenuUI.SetState(new UIResourcePackSelectionMenu(uiStateToGoBackTo, AssetSourceController, AssetInitializer.CreateResourcePackList(instance.Services)));
    }
 
    private static void CycleClothingStyle(Player plr)
    {
        CycleClothingStyle_Inner(plr);
        while (!IsValidPlayerStyle(plr))
        {
            CycleClothingStyle_Inner(plr);
        }
    }
 
    private static bool IsValidPlayerStyle(Player plr)
    {
        int skinVariant = plr.skinVariant;
        if ((uint)(skinVariant - 10) <= 1u)
        {
            return false;
        }
        return true;
    }
 
    private static void CycleClothingStyle_Inner(Player plr)
    {
        if (plr.Male)
        {
            int num = 0;
            int[] variantOrderMale = PlayerVariantID.Sets.VariantOrderMale;
            for (int i = 0; i < variantOrderMale.Length; i++)
            {
                if (variantOrderMale[i] == plr.skinVariant)
                {
                    num = i;
                    break;
                }
            }
            if (num == variantOrderMale.Length - 1)
            {
                plr.skinVariant = variantOrderMale[0];
            }
            else
            {
                plr.skinVariant = variantOrderMale[num + 1];
            }
            return;
        }
        int num2 = 0;
        int[] variantOrderFemale = PlayerVariantID.Sets.VariantOrderFemale;
        for (int j = 0; j < variantOrderFemale.Length; j++)
        {
            if (variantOrderFemale[j] == plr.skinVariant)
            {
                num2 = j;
                break;
            }
        }
        if (num2 == variantOrderFemale.Length - 1)
        {
            plr.skinVariant = variantOrderFemale[0];
        }
        else
        {
            plr.skinVariant = variantOrderFemale[num2 + 1];
        }
    }
 
    public static void ResetKeyBindings()
    {
        cUp = "W";
        cDown = "S";
        cLeft = "A";
        cRight = "D";
        cJump = "Space";
        cThrowItem = "T";
        cInv = "Escape";
        cHeal = "H";
        cMana = "J";
        cBuff = "B";
        cHook = "E";
        cTorch = "LeftShift";
        cSmart = "LeftControl";
        cMount = "R";
    }
 
    public static void CursorColor()
    {
        cursorAlpha += (float)cursorColorDirection * 0.015f;
        if (cursorAlpha >= 1f)
        {
            cursorAlpha = 1f;
            cursorColorDirection = -1;
        }
        if ((double)cursorAlpha <= 0.6)
        {
            cursorAlpha = 0.6f;
            cursorColorDirection = 1;
        }
        float num = cursorAlpha * 0.3f + 0.7f;
        byte r = (byte)((float)(int)mouseColor.R * cursorAlpha);
        byte g = (byte)((float)(int)mouseColor.G * cursorAlpha);
        byte b = (byte)((float)(int)mouseColor.B * cursorAlpha);
        byte a = (byte)(255f * num);
        cursorColor = new Microsoft.Xna.Framework.Color(r, g, b, a);
        cursorScale = cursorAlpha * 0.3f + 0.7f + 0.1f;
    }
 
    protected void DrawSplash(GameTime gameTime)
    {
        int num = 10000;
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Black);
        base.Draw(gameTime);
        TickLoadProcess();
        long num2 = splashTimer.ElapsedMilliseconds;
        if (musicVolume == 0f)
        {
            quickSplash = true;
            num2 = 999999L;
            num = 0;
        }
        if (Assets.PendingAssets == 0 && _musicLoaded && _artLoaded && Program.LoadedEverything)
        {
            _isAsyncLoadComplete = true;
        }
        spriteBatch.Begin();
        splashCounter++;
        Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
        byte b = 0;
        if (quickSplash)
        {
            if (splashCounter <= 75)
            {
                b = (byte)((float)splashCounter / 75f * 255f);
            }
            else if (splashCounter <= 125)
            {
                b = byte.MaxValue;
            }
            else if (splashCounter <= 200)
            {
                if (!_isAsyncLoadComplete)
                {
                    splashCounter = 125;
                }
                b = (byte)((float)(75 - (splashCounter - 125)) / 75f * 255f);
            }
            else
            {
                Initialize_AlmostEverything();
                PostContentLoadInitialize();
                showSplash = false;
                fadeCounter = 75;
                splashTimer.Stop();
            }
        }
        else
        {
            int num3 = 90;
            int num4 = 410;
            int num5 = 620;
            int num6 = 60;
            if (splashCounter >= num3)
            {
                if (splashCounter <= num4)
                {
                    float num7 = (float)(splashCounter - num3) / (float)(num4 - num3);
                    num7 *= num7 * num7 * num7;
                    num7 *= 255f;
                    b = (byte)num7;
                }
                else if (splashCounter <= num5)
                {
                    b = byte.MaxValue;
                    if (splashCounter >= num5 - num6)
                    {
                        b = (byte)((float)(num6 - (splashCounter - (num5 - num6))) / (float)num6 * 255f);
                    }
                }
                else if (!_isAsyncLoadComplete)
                {
                    b = 0;
                    num = 1;
                }
                else
                {
                    Initialize_AlmostEverything();
                    PostContentLoadInitialize();
                    showSplash = false;
                    fadeCounter = 120;
                    splashTimer.Stop();
                }
            }
        }
        white = new Microsoft.Xna.Framework.Color(b, b, b, b);
        Asset<Texture2D> splashTextureLegoBack = TextureAssets.SplashTextureLegoBack;
        if (splashTextureLegoBack.Width() > 0 && splashTextureLegoBack.Height() > 0)
        {
            Vector2 vector = new Vector2((float)screenWidth / (float)splashTextureLegoBack.Width(), (float)screenHeight / (float)splashTextureLegoBack.Height());
            _ = splashTextureLegoBack.Size() / 2f;
            Vector2 position = new Vector2(screenWidth, screenHeight) / 2f;
            Vector2 scale = vector;
            if (scale.X > scale.Y)
            {
                scale.X = scale.Y;
            }
            else
            {
                scale.Y = scale.X;
            }
            Vector2 scale2 = vector;
            if (scale2.X < scale2.Y)
            {
                scale2.X = scale2.Y;
            }
            else
            {
                scale2.Y = scale2.X;
            }
            spriteBatch.Draw(splashTextureLegoBack.Value, position, null, white, 0f, splashTextureLegoBack.Size() / 2f, scale2, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.SplashTextureLegoTree.Value, ScreenSize.ToVector2(), null, white, 0f, TextureAssets.SplashTextureLegoTree.Size(), scale, SpriteEffects.None, 0f);
            spriteBatch.Draw(TextureAssets.SplashTextureLegoFront.Value, position, null, white, 0f, TextureAssets.SplashTextureLegoFront.Size() / 2f, scale, SpriteEffects.None, 0f);
        }
        int num8 = 70;
        if (num == 1)
        {
            DrawSplash_LoadingFlower(Microsoft.Xna.Framework.Color.White);
        }
        else if (num2 > num)
        {
            DrawSplash_LoadingFlower(white);
        }
        _splashFrameCount += 1f;
        if (_splashFrameCount >= (float)num8)
        {
            _splashFrameCount = 0f;
        }
        spriteBatch.End();
    }
 
    private void DrawSplash_LoadingFlower(Microsoft.Xna.Framework.Color splashColor)
    {
        float val = (float)screenWidth / MinimumZoomComparerX;
        float val2 = (float)screenHeight / MinimumZoomComparerY;
        float num = Math.Max(Math.Max(1f, val), val2);
        Texture2D value = TextureAssets.LoadingSunflower.Value;
        int num2 = 3;
        int num3 = 19;
        Vector2 position = new Vector2(screenWidth / 2, screenHeight) - new Vector2(0f, 50f) * num;
        int num4 = (int)_splashFrameCount / num2;
        if (num4 >= num3)
        {
            num4 = 0;
        }
        Microsoft.Xna.Framework.Rectangle rectangle = value.Frame(1, num3, 0, (num4 + 10) % num3);
        float rotation = 0f;
        Vector2 origin = rectangle.Size() / 2f;
        spriteBatch.Draw(value, position, rectangle, splashColor, rotation, origin, num, SpriteEffects.None, 0f);
    }
 
    private void DrawSplash_LoadingStar(Microsoft.Xna.Framework.Color splashColor)
    {
        int num = 4;
        Vector2 position = new Vector2(screenWidth, screenHeight) - new Vector2(30f);
        int num2 = (int)_splashFrameCount / num;
        if (num2 >= 15)
        {
            num2 = 0;
        }
        if (num2 >= 8)
        {
            num2 = 14 - num2;
        }
        Microsoft.Xna.Framework.Rectangle rectangle = TextureAssets.Item[75].Frame(1, 8, 0, num2);
        rectangle.Height -= 2;
        float rotation = 0f;
        Vector2 origin = rectangle.Size() / 2f;
        origin.Y += 2f;
        spriteBatch.Draw(TextureAssets.Item[75].Value, position, rectangle, splashColor, rotation, origin, 1f, SpriteEffects.None, 0f);
    }
 
    protected void DrawUnderworldBackground(bool flat)
    {
        if (!(screenPosition.Y + (float)screenHeight < (float)(maxTilesY - 220) * 16f))
        {
            Vector2 screenOffset = screenPosition + new Vector2(screenWidth >> 1, screenHeight >> 1);
            float pushUp = (GameViewMatrix.Zoom.Y - 1f) * 0.5f * 200f;
            SkyManager.Instance.ResetDepthTracker();
            for (int num = 4; num >= 0; num--)
            {
                DrawUnderworldBackgroudLayer(flat, screenOffset, pushUp, num);
            }
            if (!mapFullscreen)
            {
                SkyManager.Instance.DrawRemainingDepth(spriteBatch);
            }
            DrawSurfaceBG_DrawChangeOverlay(12);
        }
    }
 
    private static void DrawUnderworldBackgroudLayer(bool flat, Vector2 screenOffset, float pushUp, int layerTextureIndex)
    {
        int num = underworldBG[layerTextureIndex];
        Asset<Texture2D> val = TextureAssets.Underworld[num];
        if (!val.IsLoaded)
        {
            Assets.Request<Texture2D>(val.Name, (AssetRequestMode)1);
        }
        Texture2D value = val.Value;
        Vector2 vec = new Vector2(value.Width, value.Height) * 0.5f;
        float num2 = (flat ? 1f : ((float)(layerTextureIndex * 2) + 3f));
        Vector2 vector = new Vector2(1f / num2);
        Microsoft.Xna.Framework.Rectangle value2 = new Microsoft.Xna.Framework.Rectangle(0, 0, value.Width, value.Height);
        float num3 = 1.3f;
        Vector2 zero = Vector2.Zero;
        int num4 = 0;
        switch (num)
        {
        case 1:
        {
            int num9 = (int)(GlobalTimeWrappedHourly * 8f) % 4;
            value2 = new Microsoft.Xna.Framework.Rectangle((num9 >> 1) * (value.Width >> 1), num9 % 2 * (value.Height >> 1), value.Width >> 1, value.Height >> 1);
            vec *= 0.5f;
            zero.Y += 175f;
            break;
        }
        case 2:
            zero.Y += 100f;
            break;
        case 3:
            zero.Y += 75f;
            break;
        case 4:
            num3 = 0.5f;
            zero.Y -= 0f;
            break;
        case 5:
            zero.Y += num4;
            break;
        case 6:
        {
            int num8 = (int)(GlobalTimeWrappedHourly * 8f) % 4;
            value2 = new Microsoft.Xna.Framework.Rectangle(num8 % 2 * (value.Width >> 1), (num8 >> 1) * (value.Height >> 1), value.Width >> 1, value.Height >> 1);
            vec *= 0.5f;
            zero.Y += num4;
            zero.Y += -60f;
            break;
        }
        case 7:
        {
            int num7 = (int)(GlobalTimeWrappedHourly * 8f) % 4;
            value2 = new Microsoft.Xna.Framework.Rectangle(num7 % 2 * (value.Width >> 1), (num7 >> 1) * (value.Height >> 1), value.Width >> 1, value.Height >> 1);
            vec *= 0.5f;
            zero.Y += num4;
            zero.X -= 400f;
            zero.Y += 90f;
            break;
        }
        case 8:
        {
            int num6 = (int)(GlobalTimeWrappedHourly * 8f) % 4;
            value2 = new Microsoft.Xna.Framework.Rectangle(num6 % 2 * (value.Width >> 1), (num6 >> 1) * (value.Height >> 1), value.Width >> 1, value.Height >> 1);
            vec *= 0.5f;
            zero.Y += num4;
            zero.Y += 90f;
            break;
        }
        case 9:
            zero.Y += num4;
            zero.Y -= 30f;
            break;
        case 10:
            zero.Y += 250f * num2;
            break;
        case 11:
            zero.Y += 100f * num2;
            break;
        case 12:
            zero.Y += 20f * num2;
            break;
        case 13:
        {
            zero.Y += 20f * num2;
            int num5 = (int)(GlobalTimeWrappedHourly * 8f) % 4;
            value2 = new Microsoft.Xna.Framework.Rectangle(num5 % 2 * (value.Width >> 1), (num5 >> 1) * (value.Height >> 1), value.Width >> 1, value.Height >> 1);
            vec *= 0.5f;
            break;
        }
        }
        if (flat)
        {
            num3 *= 1.5f;
        }
        vec *= num3;
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / vector.X);
        if (flat)
        {
            zero.Y += (float)(TextureAssets.Underworld[0].Height() >> 1) * 1.3f - vec.Y;
        }
        zero.Y -= pushUp;
        float num10 = num3 * (float)value2.Width;
        int num11 = (int)((float)(int)(screenOffset.X * vector.X - vec.X + zero.X - (float)(screenWidth >> 1)) / num10);
        vec = vec.Floor();
        int num12 = (int)Math.Ceiling((float)screenWidth / num10);
        int num13 = (int)(num3 * ((float)(value2.Width - 1) / vector.X));
        Vector2 vec2 = (new Vector2((num11 - 2) * num13, (float)UnderworldLayer * 16f) + vec - screenOffset) * vector + screenOffset - screenPosition - vec + zero;
        vec2 = vec2.Floor();
        while (vec2.X + num10 < 0f)
        {
            num11++;
            vec2.X += num10;
        }
        for (int i = num11 - 2; i <= num11 + 4 + num12; i++)
        {
            spriteBatch.Draw(value, vec2, value2, Microsoft.Xna.Framework.Color.White, 0f, Vector2.Zero, num3, SpriteEffects.None, 0f);
            if (layerTextureIndex == 0)
            {
                int num14 = (int)(vec2.Y + (float)value2.Height * num3);
                spriteBatch.Draw(TextureAssets.BlackTile.Value, new Microsoft.Xna.Framework.Rectangle((int)vec2.X, num14, (int)((float)value2.Width * num3), Math.Max(0, screenHeight - num14)), new Microsoft.Xna.Framework.Color(11, 3, 7));
            }
            vec2.X += num10;
        }
    }
 
    protected void DrawBackground()
    {
        float num = shimmerAlpha;
        if (num == 1f)
        {
            ugBackTransition = 0f;
            return;
        }
        if (!BackgroundEnabled)
        {
            OldDrawBackground();
            return;
        }
        Microsoft.Xna.Framework.Color[] slices = new Microsoft.Xna.Framework.Color[9];
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        double num2 = maxTilesY - 330;
        double num3 = (int)((num2 - worldSurface) / 6.0) * 6;
        num2 = worldSurface + num3 - 5.0;
        int num4 = (int)(255f * (1f - gfxQuality) + 140f * gfxQuality);
        int num5 = (int)(200f * (1f - gfxQuality) + 40f * gfxQuality);
        int num6 = 128;
        Vector2 vector = (drawToScreen ? Vector2.Zero : new Vector2(offScreenRange, offScreenRange));
        Vector3 vector2 = new Vector3(0.9f);
        float num7 = MathHelper.Clamp((screenPosition.Y - (float)worldSurface * 16f) / 300f, 0f, 1f);
        float globalBrightness = Lighting.GlobalBrightness;
        Lighting.GlobalBrightness = globalBrightness * (1f - num7) + 1f * num7;
        float value = (float)((double)(screenPosition.Y - (float)(screenHeight / 2) + 200f) - rockLayer * 16.0) / 300f;
        value = MathHelper.Clamp(value, 0f, 1f);
        int num8 = (int)((screenPosition.X + (float)(screenWidth / 2)) / 16f);
        int num9 = 3;
        num9 = ((num8 <= caveBackX[0]) ? caveBackStyle[0] : ((num8 <= caveBackX[1]) ? caveBackStyle[1] : ((num8 > caveBackX[2]) ? caveBackStyle[3] : caveBackStyle[2])));
        num9 += 3;
        if (SceneMetrics.SnowTileCount > SceneMetrics.SnowTileThreshold && (screenPosition.Y + (float)screenHeight + 1200f) / 16f < (float)(maxTilesY - 250))
        {
            num9 = 1;
        }
        if (SceneMetrics.JungleTileCount > SceneMetrics.JungleTileThreshold)
        {
            if (num9 == 1)
            {
                if (SceneMetrics.JungleTileCount > SceneMetrics.SnowTileCount)
                {
                    num9 = 11;
                }
            }
            else
            {
                num9 = 11;
            }
        }
        if (WorldGen.oceanDepths((int)(screenPosition.X + (float)(screenHeight / 2)) / 16, (int)(screenPosition.Y + (float)(screenHeight / 2)) / 16))
        {
            num9 = (player[myPlayer].ZoneCorrupt ? 19 : (player[myPlayer].ZoneCrimson ? 21 : ((!player[myPlayer].ZoneHallow) ? 18 : 20)));
        }
        else if ((double)(screenPosition.Y / 16f) > rockLayer + 60.0 && (double)(screenPosition.Y / 16f) < num2 - 60.0)
        {
            if (player[myPlayer].ZoneSnow)
            {
                if (player[myPlayer].ZoneCorrupt)
                {
                    num9 = 15;
                }
                else if (player[myPlayer].ZoneCrimson)
                {
                    num9 = 16;
                }
                else if (player[myPlayer].ZoneHallow)
                {
                    num9 = 17;
                }
            }
            else if (player[myPlayer].ZoneCorrupt)
            {
                num9 = 12;
            }
            else if (player[myPlayer].ZoneCrimson)
            {
                num9 = 13;
            }
            else if (player[myPlayer].ZoneHallow)
            {
                num9 = 14;
            }
        }
        if (player[myPlayer].ZoneGlowshroom)
        {
            num9 = 2;
        }
        if (num9 != undergroundBackground)
        {
            oldUndergroundBackground = undergroundBackground;
            undergroundBackground = num9;
            ugBackTransition = 1f;
        }
        if (num > 0f)
        {
            ugBackTransition = 0f;
        }
        if (ugBackTransition > 0f)
        {
            ugBackTransition -= 0.25f;
        }
        if (ugBackTransition < 0f)
        {
            ugBackTransition = 0f;
        }
        int[] array = new int[7];
        int[] array2 = new int[7];
        for (int i = 0; i < 2; i++)
        {
            int num10 = undergroundBackground;
            if (i == 1)
            {
                num10 = oldUndergroundBackground;
            }
            int[] array3 = new int[7];
            switch (num10)
            {
            case 0:
                array3[0] = 1;
                array3[1] = 2;
                array3[2] = 4;
                array3[3] = 3;
                array3[4] = 6;
                array3[5] = 5;
                break;
            case 1:
                if (iceBackStyle == 0)
                {
                    array3[1] = 33;
                    array3[3] = 32;
                    array3[0] = 40;
                    array3[2] = 34;
                }
                else if (iceBackStyle == 1)
                {
                    array3[1] = 118;
                    array3[3] = 117;
                    array3[0] = 160;
                    array3[2] = 161;
                }
                else if (iceBackStyle == 2)
                {
                    array3[1] = 165;
                    array3[3] = 167;
                    array3[0] = 164;
                    array3[2] = 166;
                }
                else
                {
                    array3[1] = 120;
                    array3[3] = 119;
                    array3[0] = 162;
                    array3[2] = 163;
                }
                array3[4] = 128 + hellBackStyle;
                break;
            case 2:
                array3[0] = 62;
                array3[1] = 63;
                array3[2] = 64;
                array3[3] = 65;
                array3[4] = 143 + hellBackStyle;
                break;
            case 3:
                array3[0] = 66;
                array3[1] = 67;
                array3[2] = 68;
                array3[3] = 69;
                array3[4] = 128 + hellBackStyle;
                break;
            case 4:
                array3[0] = 70;
                array3[1] = 71;
                array3[2] = 68;
                array3[3] = 72;
                array3[4] = 128 + hellBackStyle;
                break;
            case 5:
                array3[0] = 73;
                array3[1] = 74;
                array3[2] = 75;
                array3[3] = 76;
                array3[4] = 131 + hellBackStyle;
                break;
            case 6:
                array3[0] = 77;
                array3[1] = 78;
                array3[2] = 79;
                array3[3] = 80;
                array3[4] = 134 + hellBackStyle;
                break;
            case 7:
                array3[0] = 77;
                array3[1] = 81;
                array3[2] = 79;
                array3[3] = 82;
                array3[4] = 134 + hellBackStyle;
                break;
            case 8:
                array3[0] = 83;
                array3[1] = 84;
                array3[2] = 85;
                array3[3] = 86;
                array3[4] = 137 + hellBackStyle;
                break;
            case 9:
                array3[0] = 83;
                array3[1] = 87;
                array3[2] = 88;
                array3[3] = 89;
                array3[4] = 137 + hellBackStyle;
                break;
            case 10:
                array3[0] = 121;
                array3[1] = 122;
                array3[2] = 123;
                array3[3] = 124;
                array3[4] = 140 + hellBackStyle;
                break;
            case 11:
                if (jungleBackStyle == 0)
                {
                    array3[0] = 153;
                    array3[1] = 147;
                    array3[2] = 148;
                    array3[3] = 149;
                    array3[4] = 150 + hellBackStyle;
                }
                else
                {
                    array3[0] = 146;
                    array3[1] = 154;
                    array3[2] = 155;
                    array3[3] = 156;
                    array3[4] = 157 + hellBackStyle;
                }
                break;
            case 12:
            case 13:
            case 14:
                array3[0] = 66;
                array3[1] = 67;
                array3[2] = 68;
                array3[4] = 128 + hellBackStyle;
                switch (num10)
                {
                case 12:
                    array3[3] = 193 + worldID % 4;
                    break;
                case 13:
                    array3[3] = 188 + worldID % 5;
                    break;
                case 14:
                    array3[3] = 197 + worldID % 3;
                    break;
                }
                break;
            default:
                if (num10 >= 15 && num10 <= 17)
                {
                    array3[0] = 40;
                    array3[1] = 33;
                    array3[2] = 34;
                    array3[4] = 128 + hellBackStyle;
                    switch (num10)
                    {
                    case 15:
                        array3[3] = 200;
                        break;
                    case 16:
                        array3[3] = 201 + worldID % 2;
                        break;
                    case 17:
                        array3[3] = 203 + worldID % 4;
                        break;
                    }
                    break;
                }
                switch (num10)
                {
                case 18:
                    array3[0] = 290;
                    array3[1] = 291;
                    break;
                case 19:
                    array3[0] = 292;
                    array3[1] = 293;
                    break;
                case 20:
                    array3[0] = 294;
                    array3[1] = 295;
                    break;
                case 21:
                    array3[0] = 296;
                    array3[1] = 297;
                    break;
                }
                break;
            }
            if (hellBackStyle == 0)
            {
                array3[5] = 125;
            }
            if (hellBackStyle == 1)
            {
                array3[5] = 126;
            }
            if (hellBackStyle == 2)
            {
                array3[5] = 127;
            }
            array3[6] = 185 + hellBackStyle;
            LoadBackground(array3[0]);
            LoadBackground(array3[1]);
            LoadBackground(array3[2]);
            LoadBackground(array3[3]);
            LoadBackground(array3[4]);
            LoadBackground(array3[5]);
            LoadBackground(array3[6]);
            if (i == 0)
            {
                for (int j = 0; j < 7; j++)
                {
                    array[j] = array3[j];
                }
            }
            else
            {
                for (int k = 0; k < 7; k++)
                {
                    array2[k] = array3[k];
                }
            }
        }
        globalBrightness = 1.2f - 0.2f * value;
        float x = vector2.X;
        float y = vector2.Y;
        float z = vector2.Z;
        num6 = TextureAssets.Background[array[0]].Width() - 32;
        bgParallax = caveParallax;
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
        bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
        bgTopY = (int)((float)((int)worldSurface * 16 - 16) - screenPosition.Y + 16f);
        for (int l = 0; l < bgLoops; l++)
        {
            for (int m = 0; m < num6 / 16; m++)
            {
                int num11 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
                if (num11 == -8)
                {
                    num11 = 8;
                }
                float num12 = bgStartX + num6 * l + m * 16 + 8;
                float num13 = bgTopY;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)((num12 + screenPosition.X) / 16f), (int)((screenPosition.Y + num13) / 16f));
                color.R = (byte)((float)(int)color.R * x);
                color.G = (byte)((float)(int)color.G * y);
                color.B = (byte)((float)(int)color.B * z);
                if (num > 0f)
                {
                    color *= 1f - num;
                }
                spriteBatch.Draw(TextureAssets.Background[array[0]].Value, new Vector2(bgStartX + num6 * l + 16 * m + num11, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * m + num11 + 16, 0, 16, 16), color);
            }
        }
        if (ugBackTransition > 0f)
        {
            num6 = TextureAssets.Background[array2[0]].Width() - 32;
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
            for (int n = 0; n < bgLoops; n++)
            {
                for (int num14 = 0; num14 < num6 / 16; num14++)
                {
                    int num15 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
                    if (num15 == -8)
                    {
                        num15 = 8;
                    }
                    float num16 = bgStartX + num6 * n + num14 * 16 + 8;
                    float num17 = bgTopY;
                    Microsoft.Xna.Framework.Color color2 = Lighting.GetColor((int)((num16 + screenPosition.X) / 16f), (int)((screenPosition.Y + num17) / 16f));
                    color2.R = (byte)((float)(int)color2.R * x);
                    color2.G = (byte)((float)(int)color2.G * y);
                    color2.B = (byte)((float)(int)color2.B * z);
                    Microsoft.Xna.Framework.Color color3 = color2;
                    color3.R = (byte)((float)(int)color3.R * ugBackTransition);
                    color3.G = (byte)((float)(int)color3.G * ugBackTransition);
                    color3.B = (byte)((float)(int)color3.B * ugBackTransition);
                    color3.A = (byte)((float)(int)color3.A * ugBackTransition);
                    spriteBatch.Draw(TextureAssets.Background[array2[0]].Value, new Vector2(bgStartX + num6 * n + 16 * num14 + num15, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num14 + num15 + 16, 0, 16, 16), color3);
                }
            }
        }
        bool flag = false;
        bool flag2 = false;
        bgTopY = (int)((float)((int)worldSurface * 16) - screenPosition.Y + 16f);
        if (worldSurface * 16.0 <= (double)(screenPosition.Y + (float)screenHeight + (float)offScreenRange))
        {
            bgParallax = caveParallax;
            num6 = TextureAssets.Background[array[1]].Width() - 32;
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
            if (worldSurface * 16.0 < (double)(screenPosition.Y - 16f))
            {
                bgStartY = (int)(Math.IEEERemainder(bgTopY, backgroundHeight[2]) - (double)backgroundHeight[2]);
                bgLoopsY = (screenHeight - bgStartY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            else
            {
                bgStartY = bgTopY;
                bgLoopsY = (screenHeight - bgTopY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            if (rockLayer * 16.0 < (double)(Camera.ScaledPosition.Y + 600f))
            {
                bgLoopsY = (int)(rockLayer * 16.0 - (double)screenPosition.Y + 600.0 - (double)bgStartY) / backgroundHeight[2];
                flag2 = true;
            }
            int num18 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
            if (num18 == -8)
            {
                num18 = 8;
            }
            for (int num19 = 0; num19 < bgLoops; num19++)
            {
                for (int num20 = 0; num20 < bgLoopsY; num20++)
                {
                    for (int num21 = 0; num21 < num6 / 16; num21++)
                    {
                        for (int num22 = 0; num22 < 6; num22++)
                        {
                            float num23 = bgStartY + num20 * 96 + num22 * 16 + 8;
                            int num24 = (int)(((float)(bgStartX + num6 * num19 + num21 * 16 + 8) + screenPosition.X) / 16f);
                            int num25 = (int)((num23 + screenPosition.Y) / 16f);
                            Microsoft.Xna.Framework.Color color4 = Lighting.GetColor(num24, num25);
                            if (!WorldGen.InWorld(num24, num25))
                            {
                                continue;
                            }
                            if (tile[num24, num25] == null)
                            {
                                tile[num24, num25] = new Tile();
                            }
                            if (num == 0f && (color4.R > 0 || color4.G > 0 || color4.B > 0))
                            {
                                if (!drawToScreen)
                                {
                                    Lighting.GetCornerColors(num24, num25, out var vertices);
                                    vertices.BottomLeftColor = new Microsoft.Xna.Framework.Color(vertices.BottomLeftColor.ToVector3() * vector2);
                                    vertices.BottomRightColor = new Microsoft.Xna.Framework.Color(vertices.BottomRightColor.ToVector3() * vector2);
                                    tileBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num18, bgStartY + backgroundHeight[array2[1]] * num20 + 16 * num22) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num18 + 16, 16 * num22, 16, 16), vertices, Vector2.Zero, 1f, SpriteEffects.None);
                                }
                                else if ((color4.R > num4 || (double)(int)color4.G > (double)num4 * 1.1 || (double)(int)color4.B > (double)num4 * 1.2) && !tile[num24, num25].active() && WallLightAt(num24, num25) && ugBackTransition == 0f)
                                {
                                    Lighting.GetColor9Slice(num24, num25, ref slices);
                                    try
                                    {
                                        for (int num26 = 0; num26 < 9; num26++)
                                        {
                                            int num27 = 0;
                                            int num28 = 0;
                                            int width = 4;
                                            int height = 4;
                                            Microsoft.Xna.Framework.Color color5 = color4;
                                            Microsoft.Xna.Framework.Color color6 = color4;
                                            switch (num26)
                                            {
                                            case 0:
                                                if (!tile[num24 - 1, num25 - 1].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 1:
                                                width = 8;
                                                num27 = 4;
                                                if (!tile[num24, num25 - 1].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 2:
                                                num27 = 12;
                                                if (!tile[num24 + 1, num25 - 1].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 3:
                                                height = 8;
                                                num28 = 4;
                                                if (!tile[num24 - 1, num25].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 4:
                                                width = 8;
                                                height = 8;
                                                num27 = 4;
                                                num28 = 4;
                                                break;
                                            case 5:
                                                num27 = 12;
                                                num28 = 4;
                                                height = 8;
                                                if (!tile[num24 + 1, num25].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 6:
                                                num28 = 12;
                                                if (!tile[num24 - 1, num25 + 1].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 7:
                                                width = 8;
                                                height = 4;
                                                num27 = 4;
                                                num28 = 12;
                                                if (!tile[num24, num25 + 1].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            case 8:
                                                num27 = 12;
                                                num28 = 12;
                                                if (!tile[num24 + 1, num25 + 1].active())
                                                {
                                                    color6 = slices[num26];
                                                }
                                                break;
                                            }
                                            color5.R = (byte)((color4.R + color6.R) / 2);
                                            color5.G = (byte)((color4.G + color6.G) / 2);
                                            color5.B = (byte)((color4.B + color6.B) / 2);
                                            color5.R = (byte)((float)(int)color5.R * x);
                                            color5.G = (byte)((float)(int)color5.G * y);
                                            color5.B = (byte)((float)(int)color5.B * z);
                                            spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num27 + num18, bgStartY + backgroundHeight[array[1]] * num20 + 16 * num22 + num28) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num27 + num18 + 16, 16 * num22 + num28, width, height), color5);
                                            if (ugBackTransition > 0f)
                                            {
                                                Microsoft.Xna.Framework.Color color7 = color5;
                                                color7.R = (byte)((float)(int)color7.R * ugBackTransition);
                                                color7.G = (byte)((float)(int)color7.G * ugBackTransition);
                                                color7.B = (byte)((float)(int)color7.B * ugBackTransition);
                                                color7.A = (byte)((float)(int)color7.A * ugBackTransition);
                                                spriteBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num27 + num18, bgStartY + backgroundHeight[array2[1]] * num20 + 16 * num22 + num28) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num27 + num18 + 16, 16 * num22 + num28, width, height), color7);
                                            }
                                        }
                                    }
                                    catch
                                    {
                                        color4.R = (byte)((float)(int)color4.R * x);
                                        color4.G = (byte)((float)(int)color4.G * y);
                                        color4.B = (byte)((float)(int)color4.B * z);
                                        spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num18, bgStartY + backgroundHeight[array[1]] * num20 + 16 * num22) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num18 + 16, 16 * num22, 16, 16), color4);
                                    }
                                }
                                else if ((color4.R > num5 || (double)(int)color4.G > (double)num5 * 1.1 || (double)(int)color4.B > (double)num5 * 1.2) && ugBackTransition == 0f)
                                {
                                    Lighting.GetColor4Slice(num24, num25, ref slices);
                                    for (int num29 = 0; num29 < 4; num29++)
                                    {
                                        int num30 = 0;
                                        int num31 = 0;
                                        Microsoft.Xna.Framework.Color color8 = color4;
                                        Microsoft.Xna.Framework.Color color9 = slices[num29];
                                        switch (num29)
                                        {
                                        case 1:
                                            num30 = 8;
                                            break;
                                        case 2:
                                            num31 = 8;
                                            break;
                                        case 3:
                                            num30 = 8;
                                            num31 = 8;
                                            break;
                                        }
                                        color8.R = (byte)((color4.R + color9.R) / 2);
                                        color8.G = (byte)((color4.G + color9.G) / 2);
                                        color8.B = (byte)((color4.B + color9.B) / 2);
                                        color8.R = (byte)((float)(int)color8.R * x);
                                        color8.G = (byte)((float)(int)color8.G * y);
                                        color8.B = (byte)((float)(int)color8.B * z);
                                        spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num30 + num18, bgStartY + backgroundHeight[array[1]] * num20 + 16 * num22 + num31) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num30 + num18 + 16, 16 * num22 + num31, 8, 8), color8);
                                        if (ugBackTransition > 0f)
                                        {
                                            Microsoft.Xna.Framework.Color color10 = color8;
                                            color10.R = (byte)((float)(int)color10.R * ugBackTransition);
                                            color10.G = (byte)((float)(int)color10.G * ugBackTransition);
                                            color10.B = (byte)((float)(int)color10.B * ugBackTransition);
                                            color10.A = (byte)((float)(int)color10.A * ugBackTransition);
                                            spriteBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num30 + num18, bgStartY + backgroundHeight[array2[1]] * num20 + 16 * num22 + num31) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num30 + num18 + 16, 16 * num22 + num31, 8, 8), color10);
                                        }
                                    }
                                }
                                else
                                {
                                    color4.R = (byte)((float)(int)color4.R * x);
                                    color4.G = (byte)((float)(int)color4.G * y);
                                    color4.B = (byte)((float)(int)color4.B * z);
                                    spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num18, bgStartY + backgroundHeight[array[1]] * num20 + 16 * num22) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num18 + 16, 16 * num22, 16, 16), color4);
                                    if (ugBackTransition > 0f)
                                    {
                                        Microsoft.Xna.Framework.Color color11 = color4;
                                        color11.R = (byte)((float)(int)color11.R * ugBackTransition);
                                        color11.G = (byte)((float)(int)color11.G * ugBackTransition);
                                        color11.B = (byte)((float)(int)color11.B * ugBackTransition);
                                        color11.A = (byte)((float)(int)color11.A * ugBackTransition);
                                        spriteBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num18, bgStartY + backgroundHeight[array2[1]] * num20 + 16 * num22) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num18 + 16, 16 * num22, 16, 16), color11);
                                    }
                                }
                            }
                            else
                            {
                                color4.R = (byte)((float)(int)color4.R * x);
                                color4.G = (byte)((float)(int)color4.G * y);
                                color4.B = (byte)((float)(int)color4.B * z);
                                if (num > 0f)
                                {
                                    color4 *= 1f - num;
                                }
                                spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num6 * num19 + 16 * num21 + num18, bgStartY + backgroundHeight[array[1]] * num20 + 16 * num22) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num21 + num18 + 16, 16 * num22, 16, 16), color4);
                            }
                        }
                    }
                }
            }
            if (ugBackTransition > 0f)
            {
                num6 = TextureAssets.Background[array2[1]].Width() - 32;
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
                bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
                num18 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
                if (num18 == -8)
                {
                    num18 = 8;
                }
                for (int num32 = 0; num32 < bgLoops; num32++)
                {
                    for (int num33 = 0; num33 < bgLoopsY; num33++)
                    {
                        for (int num34 = 0; num34 < num6 / 16; num34++)
                        {
                            for (int num35 = 0; num35 < 6; num35++)
                            {
                                float num36 = bgStartY + num33 * 96 + num35 * 16 + 8;
                                int num37 = (int)(((float)(bgStartX + num6 * num32 + num34 * 16 + 8) + screenPosition.X) / 16f);
                                int num38 = (int)((num36 + screenPosition.Y) / 16f);
                                if (WorldGen.InWorld(num37, num38))
                                {
                                    Microsoft.Xna.Framework.Color color12 = Lighting.GetColor(num37, num38);
                                    if (tile[num37, num38] == null)
                                    {
                                        tile[num37, num38] = new Tile();
                                    }
                                    if (color12.R > 0 || color12.G > 0 || color12.B > 0)
                                    {
                                        Lighting.GetCornerColors(num37, num38, out var vertices2, ugBackTransition);
                                        byte a = (byte)(255f * ugBackTransition);
                                        vertices2.BottomLeftColor.A = a;
                                        vertices2.BottomRightColor.A = a;
                                        vertices2.TopLeftColor.A = a;
                                        vertices2.TopRightColor.A = a;
                                        tileBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num6 * num32 + 16 * num34 + num18, bgStartY + backgroundHeight[array2[1]] * num33 + 16 * num35) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num34 + num18 + 16, 16 * num35, 16, 16), vertices2, Vector2.Zero, 1f, SpriteEffects.None);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            num6 = 128;
            if (flag2)
            {
                bgParallax = caveParallax;
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
                bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
                bgTopY = bgStartY + bgLoopsY * backgroundHeight[2];
                if (bgTopY > -32)
                {
                    for (int num39 = 0; num39 < bgLoops; num39++)
                    {
                        for (int num40 = 0; num40 < num6 / 16; num40++)
                        {
                            float num41 = bgStartX + num6 * num39 + num40 * 16 + 8;
                            float num42 = bgTopY;
                            Microsoft.Xna.Framework.Color color13 = Lighting.GetColor((int)((num41 + screenPosition.X) / 16f), (int)((screenPosition.Y + num42) / 16f));
                            color13.R = (byte)((float)(int)color13.R * x);
                            color13.G = (byte)((float)(int)color13.G * y);
                            color13.B = (byte)((float)(int)color13.B * z);
                            if (num > 0f)
                            {
                                color13 *= 1f - num;
                            }
                            spriteBatch.Draw(TextureAssets.Background[array[2]].Value, new Vector2(bgStartX + num6 * num39 + 16 * num40 + num18, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num40 + num18 + 16, 0, 16, 16), color13);
                            if (ugBackTransition > 0f)
                            {
                                Microsoft.Xna.Framework.Color color14 = color13;
                                color14.R = (byte)((float)(int)color14.R * ugBackTransition);
                                color14.G = (byte)((float)(int)color14.G * ugBackTransition);
                                color14.B = (byte)((float)(int)color14.B * ugBackTransition);
                                color14.A = (byte)((float)(int)color14.A * ugBackTransition);
                                spriteBatch.Draw(TextureAssets.Background[array2[2]].Value, new Vector2(bgStartX + num6 * num39 + 16 * num40 + num18, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num40 + num18 + 16, 0, 16, 16), color14);
                            }
                        }
                    }
                }
            }
        }
        if (num2 * 16.0 <= (double)(screenPosition.Y + (float)screenHeight) && (!remixWorld || maxTilesX >= 5000))
        {
            int y2 = 0;
            int x2 = 0;
            int num43 = screenHeight + 200;
            int width2 = screenWidth + 100;
            if ((float)UnderworldLayer * 16f < screenPosition.Y + (float)screenHeight)
            {
                int num44 = (int)(hellBlackBoxBottom - screenPosition.Y + vector.Y);
                if (num43 > num44)
                {
                    num43 = num44;
                }
            }
            spriteBatch.Draw(TextureAssets.BlackTile.Value, new Microsoft.Xna.Framework.Rectangle(x2, y2, width2, num43), new Microsoft.Xna.Framework.Color(0, 0, 0));
        }
        hellBlackBoxBottom = screenPosition.Y + (float)screenHeight + 100f;
        bgTopY = (int)((float)((int)rockLayer * 16) - screenPosition.Y + 16f + 600f - 8f);
        if (rockLayer * 16.0 <= (double)(screenPosition.Y + (float)screenHeight))
        {
            bgParallax = caveParallax;
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
            if (rockLayer * 16.0 + (double)screenHeight < (double)(screenPosition.Y - 16f))
            {
                bgStartY = (int)(Math.IEEERemainder(bgTopY, backgroundHeight[3]) - (double)backgroundHeight[3]);
                bgLoopsY = (screenHeight - bgStartY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            else
            {
                bgStartY = bgTopY;
                bgLoopsY = (screenHeight - bgTopY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            if (num2 * 16.0 < (double)(screenPosition.Y + (float)screenHeight))
            {
                bgLoopsY = (int)(num2 * 16.0 - (double)screenPosition.Y + 600.0 - (double)bgStartY) / backgroundHeight[2];
                flag = true;
            }
            int num45 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
            if (num45 == -8)
            {
                num45 = 8;
            }
            for (int num46 = 0; num46 < bgLoops; num46++)
            {
                for (int num47 = 0; num47 < bgLoopsY; num47++)
                {
                    for (int num48 = 0; num48 < num6 / 16; num48++)
                    {
                        for (int num49 = 0; num49 < 6; num49++)
                        {
                            float num50 = bgStartY + num47 * 96 + num49 * 16 + 8;
                            int num51 = (int)(((float)(bgStartX + num6 * num46 + num48 * 16 + 8) + screenPosition.X) / 16f);
                            int num52 = (int)((num50 + screenPosition.Y) / 16f);
                            if (!WorldGen.InWorld(num51, num52, 1))
                            {
                                continue;
                            }
                            Microsoft.Xna.Framework.Color color15 = Lighting.GetColor(num51, num52);
                            if ((!ShouldDrawBackgroundTileAt(num51, num52) && color15.R != 0 && color15.G != 0 && color15.B != 0) || (color15.R <= 0 && color15.G <= 0 && color15.B <= 0) || (!WallLightAt(num51, num52) && caveParallax == 0f))
                            {
                                continue;
                            }
                            if (num == 0f && Lighting.NotRetro && color15.R < 230 && color15.G < 230 && color15.B < 230 && ugBackTransition == 0f)
                            {
                                if ((color15.R > num4 || (double)(int)color15.G > (double)num4 * 1.1 || (double)(int)color15.B > (double)num4 * 1.2) && !tile[num51, num52].active())
                                {
                                    Lighting.GetColor9Slice(num51, num52, ref slices);
                                    for (int num53 = 0; num53 < 9; num53++)
                                    {
                                        int num54 = 0;
                                        int num55 = 0;
                                        int width3 = 4;
                                        int height2 = 4;
                                        Microsoft.Xna.Framework.Color color16 = color15;
                                        Microsoft.Xna.Framework.Color color17 = color15;
                                        switch (num53)
                                        {
                                        case 0:
                                            if (!tile[num51 - 1, num52 - 1].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 1:
                                            width3 = 8;
                                            num54 = 4;
                                            if (!tile[num51, num52 - 1].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 2:
                                            num54 = 12;
                                            if (!tile[num51 + 1, num52 - 1].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 3:
                                            height2 = 8;
                                            num55 = 4;
                                            if (!tile[num51 - 1, num52].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 4:
                                            width3 = 8;
                                            height2 = 8;
                                            num54 = 4;
                                            num55 = 4;
                                            break;
                                        case 5:
                                            num54 = 12;
                                            num55 = 4;
                                            height2 = 8;
                                            if (!tile[num51 + 1, num52].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 6:
                                            num55 = 12;
                                            if (!tile[num51 - 1, num52 + 1].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 7:
                                            width3 = 8;
                                            height2 = 4;
                                            num54 = 4;
                                            num55 = 12;
                                            if (!tile[num51, num52 + 1].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        case 8:
                                            num54 = 12;
                                            num55 = 12;
                                            if (!tile[num51 + 1, num52 + 1].active())
                                            {
                                                color17 = slices[num53];
                                            }
                                            break;
                                        }
                                        color16.R = (byte)((color15.R + color17.R) / 2);
                                        color16.G = (byte)((color15.G + color17.G) / 2);
                                        color16.B = (byte)((color15.B + color17.B) / 2);
                                        color16.R = (byte)((float)(int)color16.R * x);
                                        color16.G = (byte)((float)(int)color16.G * y);
                                        color16.B = (byte)((float)(int)color16.B * z);
                                        spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num54 + num45, bgStartY + backgroundHeight[array[3]] * num47 + 16 * num49 + num55) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num54 + num45 + 16, 16 * num49 + num55, width3, height2), color16);
                                        if (ugBackTransition > 0f)
                                        {
                                            Microsoft.Xna.Framework.Color color18 = color16;
                                            color18.R = (byte)((float)(int)color18.R * ugBackTransition);
                                            color18.G = (byte)((float)(int)color18.G * ugBackTransition);
                                            color18.B = (byte)((float)(int)color18.B * ugBackTransition);
                                            color18.A = (byte)((float)(int)color18.A * ugBackTransition);
                                            spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num54 + num45, bgStartY + backgroundHeight[array2[3]] * num47 + 16 * num49 + num55) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num54 + num45 + 16, 16 * num49 + num55, width3, height2), color18);
                                        }
                                    }
                                }
                                else if (color15.R > num5 || (double)(int)color15.G > (double)num5 * 1.1 || (double)(int)color15.B > (double)num5 * 1.2)
                                {
                                    Lighting.GetColor4Slice(num51, num52, ref slices);
                                    for (int num56 = 0; num56 < 4; num56++)
                                    {
                                        int num57 = 0;
                                        int num58 = 0;
                                        Microsoft.Xna.Framework.Color color19 = color15;
                                        Microsoft.Xna.Framework.Color color20 = slices[num56];
                                        switch (num56)
                                        {
                                        case 1:
                                            num57 = 8;
                                            break;
                                        case 2:
                                            num58 = 8;
                                            break;
                                        case 3:
                                            num57 = 8;
                                            num58 = 8;
                                            break;
                                        }
                                        color19.R = (byte)((color15.R + color20.R) / 2);
                                        color19.G = (byte)((color15.G + color20.G) / 2);
                                        color19.B = (byte)((color15.B + color20.B) / 2);
                                        color19.R = (byte)((float)(int)color19.R * x);
                                        color19.G = (byte)((float)(int)color19.G * y);
                                        color19.B = (byte)((float)(int)color19.B * z);
                                        spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num57 + num45, bgStartY + backgroundHeight[array[3]] * num47 + 16 * num49 + num58) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num57 + num45 + 16, 16 * num49 + num58, 8, 8), color19);
                                        if (ugBackTransition > 0f)
                                        {
                                            Microsoft.Xna.Framework.Color color21 = color19;
                                            color21.R = (byte)((float)(int)color21.R * ugBackTransition);
                                            color21.G = (byte)((float)(int)color21.G * ugBackTransition);
                                            color21.B = (byte)((float)(int)color21.B * ugBackTransition);
                                            color21.A = (byte)((float)(int)color21.A * ugBackTransition);
                                            spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num57 + num45, bgStartY + backgroundHeight[array2[3]] * num47 + 16 * num49 + num58) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num57 + num45 + 16, 16 * num49 + num58, 8, 8), color21);
                                        }
                                    }
                                }
                                else
                                {
                                    color15.R = (byte)((float)(int)color15.R * x);
                                    color15.G = (byte)((float)(int)color15.G * y);
                                    color15.B = (byte)((float)(int)color15.B * z);
                                    spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num45, bgStartY + backgroundHeight[array[3]] * num47 + 16 * num49) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num45 + 16, 16 * num49, 16, 16), color15);
                                    if (ugBackTransition > 0f)
                                    {
                                        Microsoft.Xna.Framework.Color color22 = color15;
                                        color22.R = (byte)((float)(int)color22.R * ugBackTransition);
                                        color22.G = (byte)((float)(int)color22.G * ugBackTransition);
                                        color22.B = (byte)((float)(int)color22.B * ugBackTransition);
                                        color22.A = (byte)((float)(int)color22.A * ugBackTransition);
                                        spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num45, bgStartY + backgroundHeight[array2[3]] * num47 + 16 * num49) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num45 + 16, 16 * num49, 16, 16), color22);
                                    }
                                }
                            }
                            else
                            {
                                color15.R = (byte)((float)(int)color15.R * x);
                                color15.G = (byte)((float)(int)color15.G * y);
                                color15.B = (byte)((float)(int)color15.B * z);
                                if (num > 0f)
                                {
                                    color15 *= 1f - num;
                                }
                                spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num45, bgStartY + backgroundHeight[array[3]] * num47 + 16 * num49) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num45 + 16, 16 * num49, 16, 16), color15);
                                if (ugBackTransition > 0f)
                                {
                                    Microsoft.Xna.Framework.Color color23 = color15;
                                    color23.R = (byte)((float)(int)color23.R * ugBackTransition);
                                    color23.G = (byte)((float)(int)color23.G * ugBackTransition);
                                    color23.B = (byte)((float)(int)color23.B * ugBackTransition);
                                    color23.A = (byte)((float)(int)color23.A * ugBackTransition);
                                    spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num6 * num46 + 16 * num48 + num45, bgStartY + backgroundHeight[array2[3]] * num47 + 16 * num49) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num48 + num45 + 16, 16 * num49, 16, 16), color23);
                                }
                            }
                        }
                    }
                }
            }
            num6 = 128;
            if (flag)
            {
                bgParallax = caveParallax;
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
                bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
                bgTopY = bgStartY + bgLoopsY * backgroundHeight[2];
                for (int num59 = 0; num59 < bgLoops; num59++)
                {
                    for (int num60 = 0; num60 < num6 / 16; num60++)
                    {
                        float num61 = bgStartX + num6 * num59 + num60 * 16 + 8;
                        float num62 = bgTopY;
                        Microsoft.Xna.Framework.Color color24 = Lighting.GetColor((int)((num61 + screenPosition.X) / 16f), (int)((screenPosition.Y + num62) / 16f));
                        color24.R = (byte)((float)(int)color24.R * x);
                        color24.G = (byte)((float)(int)color24.G * y);
                        color24.B = (byte)((float)(int)color24.B * z);
                        spriteBatch.Draw(TextureAssets.Background[array[4]].Value, new Vector2(bgStartX + num6 * num59 + 16 * num60 + num45, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num60 + num45 + 16, magmaBGFrame * 16, 16, 16), color24);
                        if (ugBackTransition > 0f)
                        {
                            Microsoft.Xna.Framework.Color color25 = color24;
                            color25.R = (byte)((float)(int)color25.R * ugBackTransition);
                            color25.G = (byte)((float)(int)color25.G * ugBackTransition);
                            color25.B = (byte)((float)(int)color25.B * ugBackTransition);
                            color25.A = (byte)((float)(int)color25.A * ugBackTransition);
                            spriteBatch.Draw(TextureAssets.Background[array2[4]].Value, new Vector2(bgStartX + num6 * num59 + 16 * num60 + num45, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num60 + num45 + 16, magmaBGFrame * 16, 16, 16), color25);
                        }
                    }
                }
            }
        }
        bgTopY = (int)((float)((int)num2 * 16) - screenPosition.Y + 16f + 600f) - 8;
        bool flag3 = false;
        if (num2 * 16.0 <= (double)(screenPosition.Y + (float)screenHeight))
        {
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
            if (num2 * 16.0 + (double)screenHeight < (double)(screenPosition.Y - 16f))
            {
                bgStartY = (int)(Math.IEEERemainder(bgTopY, backgroundHeight[2]) - (double)backgroundHeight[2]);
                bgLoopsY = (screenHeight - bgStartY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            else
            {
                bgStartY = bgTopY;
                bgLoopsY = (screenHeight - bgTopY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            if ((float)UnderworldLayer * 16f < screenPosition.Y + (float)screenHeight)
            {
                bgLoopsY = (int)Math.Ceiling(((float)UnderworldLayer * 16f - screenPosition.Y - (float)bgStartY) / (float)backgroundHeight[2]);
                flag3 = true;
            }
            num4 = (int)((double)num4 * 1.5);
            num5 = (int)((double)num5 * 1.5);
            int num63 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
            if (num63 == -8)
            {
                num63 = 8;
            }
            for (int num64 = 0; num64 < bgLoops; num64++)
            {
                for (int num65 = 0; num65 < bgLoopsY; num65++)
                {
                    for (int num66 = 0; num66 < num6 / 16; num66++)
                    {
                        for (int num67 = 0; num67 < 6; num67++)
                        {
                            float num68 = bgStartY + num65 * 96 + num67 * 16 + 8;
                            int num69 = (int)(((float)(bgStartX + num6 * num64 + num66 * 16 + 8) + screenPosition.X) / 16f);
                            int num70 = (int)((num68 + screenPosition.Y) / 16f);
                            if (!WorldGen.InWorld(num69, num70, 1))
                            {
                                continue;
                            }
                            Microsoft.Xna.Framework.Color color26 = Lighting.GetColor(num69, num70);
                            if ((!ShouldDrawBackgroundTileAt(num69, num70) && color26.R != 0 && color26.G != 0 && color26.B != 0) || (color26.R <= 0 && color26.G <= 0 && color26.B <= 0 && num70 <= maxTilesY - 300) || (!WallLightAt(num69, num70) && caveParallax == 0f))
                            {
                                continue;
                            }
                            if (Lighting.NotRetro && color26.R < 230 && color26.G < 230 && color26.B < 230)
                            {
                                if ((color26.R > num4 || (double)(int)color26.G > (double)num4 * 1.1 || (double)(int)color26.B > (double)num4 * 1.2) && !tile[num69, num70].active())
                                {
                                    Lighting.GetColor9Slice(num69, num70, ref slices);
                                    for (int num71 = 0; num71 < 9; num71++)
                                    {
                                        int num72 = 0;
                                        int num73 = 0;
                                        int width4 = 4;
                                        int height3 = 4;
                                        Microsoft.Xna.Framework.Color color27 = color26;
                                        Microsoft.Xna.Framework.Color color28 = color26;
                                        switch (num71)
                                        {
                                        case 0:
                                            if (!tile[num69 - 1, num70 - 1].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 1:
                                            width4 = 8;
                                            num72 = 4;
                                            if (!tile[num69, num70 - 1].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 2:
                                            num72 = 12;
                                            if (!tile[num69 + 1, num70 - 1].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 3:
                                            height3 = 8;
                                            num73 = 4;
                                            if (!tile[num69 - 1, num70].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 4:
                                            width4 = 8;
                                            height3 = 8;
                                            num72 = 4;
                                            num73 = 4;
                                            break;
                                        case 5:
                                            num72 = 12;
                                            num73 = 4;
                                            height3 = 8;
                                            if (!tile[num69 + 1, num70].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 6:
                                            num73 = 12;
                                            if (!tile[num69 - 1, num70 + 1].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 7:
                                            width4 = 8;
                                            height3 = 4;
                                            num72 = 4;
                                            num73 = 12;
                                            if (!tile[num69, num70 + 1].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        case 8:
                                            num72 = 12;
                                            num73 = 12;
                                            if (!tile[num69 + 1, num70 + 1].active())
                                            {
                                                color28 = slices[num71];
                                            }
                                            break;
                                        }
                                        color27.R = (byte)((color26.R + color28.R) / 2);
                                        color27.G = (byte)((color26.G + color28.G) / 2);
                                        color27.B = (byte)((color26.B + color28.B) / 2);
                                        color27.R = (byte)((float)(int)color27.R * x);
                                        color27.G = (byte)((float)(int)color27.G * y);
                                        color27.B = (byte)((float)(int)color27.B * z);
                                        spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num6 * num64 + 16 * num66 + num72 + num63, bgStartY + backgroundHeight[2] * num65 + 16 * num67 + num73) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num66 + num72 + num63 + 16, 16 * num67 + backgroundHeight[2] * magmaBGFrame + num73, width4, height3), color27, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                                    }
                                }
                                else if (color26.R > num5 || (double)(int)color26.G > (double)num5 * 1.1 || (double)(int)color26.B > (double)num5 * 1.2)
                                {
                                    Lighting.GetColor4Slice(num69, num70, ref slices);
                                    for (int num74 = 0; num74 < 4; num74++)
                                    {
                                        int num75 = 0;
                                        int num76 = 0;
                                        Microsoft.Xna.Framework.Color color29 = color26;
                                        Microsoft.Xna.Framework.Color color30 = slices[num74];
                                        switch (num74)
                                        {
                                        case 1:
                                            num75 = 8;
                                            break;
                                        case 2:
                                            num76 = 8;
                                            break;
                                        case 3:
                                            num75 = 8;
                                            num76 = 8;
                                            break;
                                        }
                                        color29.R = (byte)((color26.R + color30.R) / 2);
                                        color29.G = (byte)((color26.G + color30.G) / 2);
                                        color29.B = (byte)((color26.B + color30.B) / 2);
                                        color29.R = (byte)((float)(int)color29.R * x);
                                        color29.G = (byte)((float)(int)color29.G * y);
                                        color29.B = (byte)((float)(int)color29.B * z);
                                        spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num6 * num64 + 16 * num66 + num75 + num63, bgStartY + backgroundHeight[2] * num65 + 16 * num67 + num76) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num66 + num75 + num63 + 16, 16 * num67 + backgroundHeight[2] * magmaBGFrame + num76, 8, 8), color29, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                                    }
                                }
                                else
                                {
                                    color26.R = (byte)((float)(int)color26.R * x);
                                    color26.G = (byte)((float)(int)color26.G * y);
                                    color26.B = (byte)((float)(int)color26.B * z);
                                    spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num6 * num64 + 16 * num66 + num63, bgStartY + backgroundHeight[2] * num65 + 16 * num67) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num66 + num63 + 16, 16 * num67 + backgroundHeight[2] * magmaBGFrame, 16, 16), color26, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                                }
                            }
                            else
                            {
                                color26.R = (byte)((float)(int)color26.R * x);
                                color26.G = (byte)((float)(int)color26.G * y);
                                color26.B = (byte)((float)(int)color26.B * z);
                                spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num6 * num64 + 16 * num66 + num63, bgStartY + backgroundHeight[2] * num65 + 16 * num67) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num66 + num63 + 16, 16 * num67 + backgroundHeight[2] * magmaBGFrame, 16, 16), color26, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                            }
                        }
                    }
                }
            }
            if (flag3)
            {
                bgParallax = caveParallax;
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)num6 + (double)screenPosition.X * bgParallax, num6) - (double)(num6 / 2)) - (int)vector.X;
                bgLoops = (screenWidth + (int)vector.X * 2) / num6 + 2;
                bgTopY = bgStartY + bgLoopsY * backgroundHeight[2];
                hellBlackBoxBottom = (float)bgTopY + screenPosition.Y;
                for (int num77 = 0; num77 < bgLoops; num77++)
                {
                    for (int num78 = 0; num78 < num6 / 16; num78++)
                    {
                        float num79 = bgStartX + num6 * num77 + num78 * 16 + 8;
                        float num80 = bgTopY;
                        Microsoft.Xna.Framework.Color color31 = Lighting.GetColor((int)((num79 + screenPosition.X) / 16f), (int)((screenPosition.Y + num80) / 16f));
                        color31.R = (byte)((float)(int)color31.R * x);
                        color31.G = (byte)((float)(int)color31.G * y);
                        color31.B = (byte)((float)(int)color31.B * z);
                        spriteBatch.Draw(TextureAssets.Background[array[6]].Value, new Vector2(bgStartX + num6 * num77 + 16 * num78 + num63, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num78 + num63 + 16, magmaBGFrame * 16, 16, 16), color31);
                        if (ugBackTransition > 0f)
                        {
                            Microsoft.Xna.Framework.Color color32 = color31;
                            color32.R = (byte)((float)(int)color32.R * ugBackTransition);
                            color32.G = (byte)((float)(int)color32.G * ugBackTransition);
                            color32.B = (byte)((float)(int)color32.B * ugBackTransition);
                            color32.A = (byte)((float)(int)color32.A * ugBackTransition);
                            spriteBatch.Draw(TextureAssets.Background[array2[6]].Value, new Vector2(bgStartX + num6 * num77 + 16 * num78 + num63, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num78 + num63 + 16, magmaBGFrame * 16, 16, 16), color32);
                        }
                    }
                }
            }
        }
        Lighting.GlobalBrightness = globalBrightness;
        TimeLogger.DrawTime(3, stopwatch.Elapsed.TotalMilliseconds);
    }
 
    public static Microsoft.Xna.Framework.Point GetScreenOverdrawOffset()
    {
        return (Camera.ScaledPosition - Camera.UnscaledPosition).ToTileCoordinates();
    }
 
    protected void OldDrawBackground()
    {
        Microsoft.Xna.Framework.Color[] slices = new Microsoft.Xna.Framework.Color[9];
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        int num = (int)(255f * (1f - gfxQuality) + 140f * gfxQuality);
        int num2 = (int)(200f * (1f - gfxQuality) + 40f * gfxQuality);
        int num3 = 128;
        Vector2 vector = new Vector2(offScreenRange, offScreenRange);
        if (drawToScreen)
        {
            vector = Vector2.Zero;
        }
        float num4;
        float num5;
        float num6 = (num5 = (num4 = 0.9f));
        float num7 = 0f;
        if (SceneMetrics.BloodTileCount > SceneMetrics.EvilTileCount && SceneMetrics.BloodTileCount > SceneMetrics.HolyTileCount)
        {
            num7 = SceneMetrics.BloodTileCount;
        }
        else if (SceneMetrics.HolyTileCount > SceneMetrics.EvilTileCount)
        {
            num7 = SceneMetrics.HolyTileCount;
        }
        else if (SceneMetrics.EvilTileCount > SceneMetrics.HolyTileCount)
        {
            num7 = SceneMetrics.EvilTileCount;
        }
        num7 = MathHelper.Clamp(num7 / 800f, 0f, 1f);
        float num8 = (float)((double)screenPosition.Y - worldSurface * 16.0) / 300f;
        if (num8 < 0f)
        {
            num8 = 0f;
        }
        else if (num8 > 1f)
        {
            num8 = 1f;
        }
        float num9 = 1f * (1f - num8) + num4 * num8;
        float globalBrightness = Lighting.GlobalBrightness;
        Lighting.GlobalBrightness = globalBrightness * (1f - num8) + 1f * num8;
        float value = (float)((double)(screenPosition.Y - (float)(screenHeight / 2) + 200f) - rockLayer * 16.0) / 300f;
        value = MathHelper.Clamp(value, 0f, 1f);
        if (SceneMetrics.BloodTileCount > SceneMetrics.EvilTileCount && SceneMetrics.BloodTileCount > SceneMetrics.HolyTileCount)
        {
            num4 = 1f * num7 + num4 * (1f - num7);
            num5 = 0.55f * num7 + num5 * (1f - num7);
            num6 = 0.5f * num7 + num6 * (1f - num7);
        }
        else if (SceneMetrics.EvilTileCount > 0)
        {
            num4 = 0.8f * num7 + num4 * (1f - num7);
            num5 = 0.75f * num7 + num5 * (1f - num7);
            num6 = 1.1f * num7 + num6 * (1f - num7);
        }
        else if (SceneMetrics.HolyTileCount > 0)
        {
            num4 = 1f * num7 + num4 * (1f - num7);
            num5 = 0.7f * num7 + num5 * (1f - num7);
            num6 = 0.9f * num7 + num6 * (1f - num7);
        }
        num4 = 1f * (num9 - value) + num4 * value;
        num5 = 1f * (num9 - value) + num5 * value;
        num6 = 1f * (num9 - value) + num6 * value;
        int num10 = (int)((screenPosition.X + (float)(screenWidth / 2)) / 16f);
        int num11 = 3;
        num11 = ((num10 <= caveBackX[0]) ? caveBackStyle[0] : ((num10 <= caveBackX[1]) ? caveBackStyle[1] : ((num10 > caveBackX[2]) ? caveBackStyle[3] : caveBackStyle[2])));
        num11 += 3;
        if (SceneMetrics.SnowTileCount > SceneMetrics.SnowTileThreshold && (screenPosition.Y + (float)screenHeight) / 16f < (float)(maxTilesY - 250))
        {
            num11 = 1;
        }
        if (SceneMetrics.JungleTileCount > SceneMetrics.JungleTileThreshold)
        {
            if (num11 == 1)
            {
                if (SceneMetrics.JungleTileCount > SceneMetrics.SnowTileCount)
                {
                    num11 = 11;
                }
            }
            else
            {
                num11 = 11;
            }
        }
        if (SceneMetrics.EnoughTilesForGlowingMushroom)
        {
            num11 = 2;
        }
        if (num11 != undergroundBackground)
        {
            oldUndergroundBackground = undergroundBackground;
            undergroundBackground = num11;
            ugBackTransition = 1f;
        }
        if (ugBackTransition > 0f)
        {
            ugBackTransition -= 0.25f;
        }
        if (ugBackTransition < 0f)
        {
            ugBackTransition = 0f;
        }
        int[] array = new int[6];
        int[] array2 = new int[6];
        for (int i = 0; i < 2; i++)
        {
            int num12 = undergroundBackground;
            if (i == 1)
            {
                num12 = oldUndergroundBackground;
            }
            int[] array3 = new int[6];
            switch (num12)
            {
            case 0:
                array3[0] = 1;
                array3[1] = 2;
                array3[2] = 4;
                array3[3] = 3;
                array3[4] = 6;
                array3[5] = 5;
                break;
            case 1:
                if (iceBackStyle == 0)
                {
                    array3[1] = 33;
                    array3[3] = 32;
                    array3[0] = 40;
                    array3[2] = 34;
                }
                else if (iceBackStyle == 1)
                {
                    array3[1] = 118;
                    array3[3] = 117;
                    array3[0] = 160;
                    array3[2] = 161;
                }
                else if (iceBackStyle == 2)
                {
                    array3[1] = 165;
                    array3[3] = 167;
                    array3[0] = 164;
                    array3[2] = 166;
                }
                else
                {
                    array3[1] = 120;
                    array3[3] = 119;
                    array3[0] = 162;
                    array3[2] = 163;
                }
                array3[4] = array3[3];
                break;
            case 2:
                array3[0] = 62;
                array3[1] = 63;
                array3[2] = 64;
                array3[3] = 65;
                array3[4] = 143 + hellBackStyle;
                break;
            case 3:
                array3[0] = 66;
                array3[1] = 67;
                array3[2] = 68;
                array3[3] = 69;
                array3[4] = 128 + hellBackStyle;
                break;
            case 4:
                array3[0] = 70;
                array3[1] = 71;
                array3[2] = 68;
                array3[3] = 72;
                array3[4] = 128 + hellBackStyle;
                break;
            case 5:
                array3[0] = 73;
                array3[1] = 74;
                array3[2] = 75;
                array3[3] = 76;
                array3[4] = 131 + hellBackStyle;
                break;
            case 6:
                array3[0] = 77;
                array3[1] = 78;
                array3[2] = 79;
                array3[3] = 80;
                array3[4] = 134 + hellBackStyle;
                break;
            case 7:
                array3[0] = 77;
                array3[1] = 81;
                array3[2] = 79;
                array3[3] = 82;
                array3[4] = 134 + hellBackStyle;
                break;
            case 8:
                array3[0] = 83;
                array3[1] = 84;
                array3[2] = 85;
                array3[3] = 86;
                array3[4] = 137 + hellBackStyle;
                break;
            case 9:
                array3[0] = 83;
                array3[1] = 87;
                array3[2] = 88;
                array3[3] = 89;
                array3[4] = 137 + hellBackStyle;
                break;
            case 10:
                array3[0] = 121;
                array3[1] = 122;
                array3[2] = 123;
                array3[3] = 124;
                array3[4] = 140 + hellBackStyle;
                break;
            case 11:
                if (jungleBackStyle == 0)
                {
                    array3[0] = 153;
                    array3[1] = 147;
                    array3[2] = 148;
                    array3[3] = 149;
                    array3[4] = 150 + hellBackStyle;
                }
                else
                {
                    array3[0] = 146;
                    array3[1] = 154;
                    array3[2] = 155;
                    array3[3] = 156;
                    array3[4] = 157 + hellBackStyle;
                }
                break;
            }
            if (hellBackStyle == 0)
            {
                array3[5] = 125;
            }
            if (hellBackStyle == 1)
            {
                array3[5] = 126;
            }
            if (hellBackStyle == 2)
            {
                array3[5] = 127;
            }
            LoadBackground(array3[0]);
            LoadBackground(array3[1]);
            LoadBackground(array3[2]);
            LoadBackground(array3[3]);
            LoadBackground(array3[4]);
            LoadBackground(array3[5]);
            if (i == 0)
            {
                for (int j = 0; j < 6; j++)
                {
                    array[j] = array3[j];
                }
            }
            else
            {
                for (int k = 0; k < 6; k++)
                {
                    array2[k] = array3[k];
                }
            }
        }
        globalBrightness = 1.2f * (1f - value) + 1f * value;
        bgParallax = caveParallax;
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)num3 + (double)screenPosition.X * bgParallax, num3) - (double)(num3 / 2)) - (int)vector.X;
        bgLoops = (screenWidth + (int)vector.X * 2) / num3 + 2;
        bgTopY = (int)((float)((int)worldSurface * 16 - 16) - screenPosition.Y + 16f);
        for (int l = 0; l < bgLoops; l++)
        {
            for (int m = 0; m < num3 / 16; m++)
            {
                int num13 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
                if (num13 == -8)
                {
                    num13 = 8;
                }
                float num14 = bgStartX + num3 * l + m * 16 + 8;
                float num15 = bgTopY;
                Microsoft.Xna.Framework.Color color = Lighting.GetColor((int)((num14 + screenPosition.X) / 16f), (int)((screenPosition.Y + num15) / 16f));
                color.R = (byte)((float)(int)color.R * num4);
                color.G = (byte)((float)(int)color.G * num5);
                color.B = (byte)((float)(int)color.B * num6);
                spriteBatch.Draw(TextureAssets.Background[array[0]].Value, new Vector2(bgStartX + num3 * l + 16 * m + num13, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * m + num13 + 16, 0, 16, 16), color);
                if (ugBackTransition > 0f)
                {
                    Microsoft.Xna.Framework.Color color2 = color;
                    color2.R = (byte)((float)(int)color2.R * ugBackTransition);
                    color2.G = (byte)((float)(int)color2.G * ugBackTransition);
                    color2.B = (byte)((float)(int)color2.B * ugBackTransition);
                    color2.A = (byte)((float)(int)color2.A * ugBackTransition);
                    spriteBatch.Draw(TextureAssets.Background[array2[0]].Value, new Vector2(bgStartX + num3 * l + 16 * m + num13, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * m + num13 + 16, 0, 16, 16), color2);
                }
            }
        }
        double num16 = maxTilesY - 230;
        double num17 = (int)((num16 - worldSurface) / 6.0) * 6;
        num16 = worldSurface + num17 - 5.0;
        bool flag = false;
        bool flag2 = false;
        bgTopY = (int)((float)((int)worldSurface * 16) - screenPosition.Y + 16f);
        if (worldSurface * 16.0 <= (double)(screenPosition.Y + (float)screenHeight + (float)offScreenRange))
        {
            bgParallax = caveParallax;
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num3 + (double)screenPosition.X * bgParallax, num3) - (double)(num3 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num3 + 2;
            if (worldSurface * 16.0 < (double)(screenPosition.Y - 16f))
            {
                bgStartY = (int)(Math.IEEERemainder(bgTopY, backgroundHeight[2]) - (double)backgroundHeight[2]);
                bgLoopsY = (screenHeight - bgStartY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            else
            {
                bgStartY = bgTopY;
                bgLoopsY = (screenHeight - bgTopY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            if (rockLayer * 16.0 < (double)(Camera.ScaledPosition.Y + 600f))
            {
                bgLoopsY = (int)(rockLayer * 16.0 - (double)screenPosition.Y + 600.0 - (double)bgStartY) / backgroundHeight[2];
                flag2 = true;
            }
            int num18 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
            if (num18 == -8)
            {
                num18 = 8;
            }
            for (int n = 0; n < bgLoops; n++)
            {
                for (int num19 = 0; num19 < bgLoopsY; num19++)
                {
                    for (int num20 = 0; num20 < num3 / 16; num20++)
                    {
                        for (int num21 = 0; num21 < 6; num21++)
                        {
                            float num22 = bgStartY + num19 * 96 + num21 * 16 + 8;
                            int num23 = (int)(((float)(bgStartX + num3 * n + num20 * 16 + 8) + screenPosition.X) / 16f);
                            int num24 = (int)((num22 + screenPosition.Y) / 16f);
                            Microsoft.Xna.Framework.Color color3 = Lighting.GetColor(num23, num24);
                            if (tile[num23, num24] == null)
                            {
                                tile[num23, num24] = new Tile();
                            }
                            if (color3.R > 0 || color3.G > 0 || color3.B > 0)
                            {
                                if (!drawToScreen)
                                {
                                    Lighting.GetCornerColors(num23, num24, out var vertices);
                                    tileBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num18, bgStartY + backgroundHeight[array2[1]] * num19 + 16 * num21) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num18 + 16, 16 * num21, 16, 16), vertices, Vector2.Zero, 1f, SpriteEffects.None);
                                }
                                else if ((color3.R > num || (double)(int)color3.G > (double)num * 1.1 || (double)(int)color3.B > (double)num * 1.2) && !tile[num23, num24].active() && WallLightAt(num23, num24) && ugBackTransition == 0f)
                                {
                                    Lighting.GetColor9Slice(num23, num24, ref slices);
                                    try
                                    {
                                        for (int num25 = 0; num25 < 9; num25++)
                                        {
                                            int num26 = 0;
                                            int num27 = 0;
                                            int width = 4;
                                            int height = 4;
                                            Microsoft.Xna.Framework.Color color4 = color3;
                                            Microsoft.Xna.Framework.Color color5 = color3;
                                            switch (num25)
                                            {
                                            case 0:
                                                if (!tile[num23 - 1, num24 - 1].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 1:
                                                width = 8;
                                                num26 = 4;
                                                if (!tile[num23, num24 - 1].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 2:
                                                num26 = 12;
                                                if (!tile[num23 + 1, num24 - 1].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 3:
                                                height = 8;
                                                num27 = 4;
                                                if (!tile[num23 - 1, num24].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 4:
                                                width = 8;
                                                height = 8;
                                                num26 = 4;
                                                num27 = 4;
                                                break;
                                            case 5:
                                                num26 = 12;
                                                num27 = 4;
                                                height = 8;
                                                if (!tile[num23 + 1, num24].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 6:
                                                num27 = 12;
                                                if (!tile[num23 - 1, num24 + 1].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 7:
                                                width = 8;
                                                height = 4;
                                                num26 = 4;
                                                num27 = 12;
                                                if (!tile[num23, num24 + 1].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            case 8:
                                                num26 = 12;
                                                num27 = 12;
                                                if (!tile[num23 + 1, num24 + 1].active())
                                                {
                                                    color5 = slices[num25];
                                                }
                                                break;
                                            }
                                            color4.R = (byte)((color3.R + color5.R) / 2);
                                            color4.G = (byte)((color3.G + color5.G) / 2);
                                            color4.B = (byte)((color3.B + color5.B) / 2);
                                            color4.R = (byte)((float)(int)color4.R * num4);
                                            color4.G = (byte)((float)(int)color4.G * num5);
                                            color4.B = (byte)((float)(int)color4.B * num6);
                                            spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num26 + num18, bgStartY + backgroundHeight[array[1]] * num19 + 16 * num21 + num27) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num26 + num18 + 16, 16 * num21 + num27, width, height), color4);
                                            if (ugBackTransition > 0f)
                                            {
                                                Microsoft.Xna.Framework.Color color6 = color4;
                                                color6.R = (byte)((float)(int)color6.R * ugBackTransition);
                                                color6.G = (byte)((float)(int)color6.G * ugBackTransition);
                                                color6.B = (byte)((float)(int)color6.B * ugBackTransition);
                                                color6.A = (byte)((float)(int)color6.A * ugBackTransition);
                                                spriteBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num26 + num18, bgStartY + backgroundHeight[array2[1]] * num19 + 16 * num21 + num27) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num26 + num18 + 16, 16 * num21 + num27, width, height), color6);
                                            }
                                        }
                                    }
                                    catch
                                    {
                                        color3.R = (byte)((float)(int)color3.R * num4);
                                        color3.G = (byte)((float)(int)color3.G * num5);
                                        color3.B = (byte)((float)(int)color3.B * num6);
                                        spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num18, bgStartY + backgroundHeight[array[1]] * num19 + 16 * num21) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num18 + 16, 16 * num21, 16, 16), color3);
                                    }
                                }
                                else if ((color3.R > num2 || (double)(int)color3.G > (double)num2 * 1.1 || (double)(int)color3.B > (double)num2 * 1.2) && ugBackTransition == 0f)
                                {
                                    Lighting.GetColor4Slice(num23, num24, ref slices);
                                    for (int num28 = 0; num28 < 4; num28++)
                                    {
                                        int num29 = 0;
                                        int num30 = 0;
                                        Microsoft.Xna.Framework.Color color7 = color3;
                                        Microsoft.Xna.Framework.Color color8 = slices[num28];
                                        switch (num28)
                                        {
                                        case 1:
                                            num29 = 8;
                                            break;
                                        case 2:
                                            num30 = 8;
                                            break;
                                        case 3:
                                            num29 = 8;
                                            num30 = 8;
                                            break;
                                        }
                                        color7.R = (byte)((color3.R + color8.R) / 2);
                                        color7.G = (byte)((color3.G + color8.G) / 2);
                                        color7.B = (byte)((color3.B + color8.B) / 2);
                                        color7.R = (byte)((float)(int)color7.R * num4);
                                        color7.G = (byte)((float)(int)color7.G * num5);
                                        color7.B = (byte)((float)(int)color7.B * num6);
                                        spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num29 + num18, bgStartY + backgroundHeight[array[1]] * num19 + 16 * num21 + num30) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num29 + num18 + 16, 16 * num21 + num30, 8, 8), color7);
                                        if (ugBackTransition > 0f)
                                        {
                                            Microsoft.Xna.Framework.Color color9 = color7;
                                            color9.R = (byte)((float)(int)color9.R * ugBackTransition);
                                            color9.G = (byte)((float)(int)color9.G * ugBackTransition);
                                            color9.B = (byte)((float)(int)color9.B * ugBackTransition);
                                            color9.A = (byte)((float)(int)color9.A * ugBackTransition);
                                            spriteBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num29 + num18, bgStartY + backgroundHeight[array2[1]] * num19 + 16 * num21 + num30) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num29 + num18 + 16, 16 * num21 + num30, 8, 8), color9);
                                        }
                                    }
                                }
                                else
                                {
                                    color3.R = (byte)((float)(int)color3.R * num4);
                                    color3.G = (byte)((float)(int)color3.G * num5);
                                    color3.B = (byte)((float)(int)color3.B * num6);
                                    spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num18, bgStartY + backgroundHeight[array[1]] * num19 + 16 * num21) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num18 + 16, 16 * num21, 16, 16), color3);
                                    if (ugBackTransition > 0f)
                                    {
                                        Microsoft.Xna.Framework.Color color10 = color3;
                                        color10.R = (byte)((float)(int)color10.R * ugBackTransition);
                                        color10.G = (byte)((float)(int)color10.G * ugBackTransition);
                                        color10.B = (byte)((float)(int)color10.B * ugBackTransition);
                                        color10.A = (byte)((float)(int)color10.A * ugBackTransition);
                                        spriteBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num18, bgStartY + backgroundHeight[array2[1]] * num19 + 16 * num21) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num18 + 16, 16 * num21, 16, 16), color10);
                                    }
                                }
                            }
                            else
                            {
                                color3.R = (byte)((float)(int)color3.R * num4);
                                color3.G = (byte)((float)(int)color3.G * num5);
                                color3.B = (byte)((float)(int)color3.B * num6);
                                spriteBatch.Draw(TextureAssets.Background[array[1]].Value, new Vector2(bgStartX + num3 * n + 16 * num20 + num18, bgStartY + backgroundHeight[array[1]] * num19 + 16 * num21) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num20 + num18 + 16, 16 * num21, 16, 16), color3);
                            }
                        }
                    }
                }
            }
            if (ugBackTransition > 0f)
            {
                for (int num31 = 0; num31 < bgLoops; num31++)
                {
                    for (int num32 = 0; num32 < bgLoopsY; num32++)
                    {
                        for (int num33 = 0; num33 < num3 / 16; num33++)
                        {
                            for (int num34 = 0; num34 < 6; num34++)
                            {
                                float num35 = bgStartY + num32 * 96 + num34 * 16 + 8;
                                int num36 = (int)(((float)(bgStartX + num3 * num31 + num33 * 16 + 8) + screenPosition.X) / 16f);
                                int num37 = (int)((num35 + screenPosition.Y) / 16f);
                                Microsoft.Xna.Framework.Color color11 = Lighting.GetColor(num36, num37);
                                if (tile[num36, num37] == null)
                                {
                                    tile[num36, num37] = new Tile();
                                }
                                if (color11.R > 0 || color11.G > 0 || color11.B > 0)
                                {
                                    Lighting.GetCornerColors(num36, num37, out var vertices2, ugBackTransition);
                                    byte a = (byte)(255f * ugBackTransition);
                                    vertices2.BottomLeftColor.A = a;
                                    vertices2.BottomRightColor.A = a;
                                    vertices2.TopLeftColor.A = a;
                                    vertices2.TopRightColor.A = a;
                                    tileBatch.Draw(TextureAssets.Background[array2[1]].Value, new Vector2(bgStartX + num3 * num31 + 16 * num33 + num18, bgStartY + backgroundHeight[array2[1]] * num32 + 16 * num34) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num33 + num18 + 16, 16 * num34, 16, 16), vertices2, Vector2.Zero, 1f, SpriteEffects.None);
                                }
                            }
                        }
                    }
                }
            }
            if (flag2)
            {
                bgParallax = caveParallax;
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)num3 + (double)screenPosition.X * bgParallax, num3) - (double)(num3 / 2)) - (int)vector.X;
                bgLoops = (screenWidth + (int)vector.X * 2) / num3 + 2;
                bgTopY = bgStartY + bgLoopsY * backgroundHeight[2];
                if (bgTopY > -32)
                {
                    for (int num38 = 0; num38 < bgLoops; num38++)
                    {
                        for (int num39 = 0; num39 < num3 / 16; num39++)
                        {
                            float num40 = bgStartX + num3 * num38 + num39 * 16 + 8;
                            float num41 = bgTopY;
                            Microsoft.Xna.Framework.Color color12 = Lighting.GetColor((int)((num40 + screenPosition.X) / 16f), (int)((screenPosition.Y + num41) / 16f));
                            color12.R = (byte)((float)(int)color12.R * num4);
                            color12.G = (byte)((float)(int)color12.G * num5);
                            color12.B = (byte)((float)(int)color12.B * num6);
                            spriteBatch.Draw(TextureAssets.Background[array[2]].Value, new Vector2(bgStartX + num3 * num38 + 16 * num39 + num18, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num39 + num18 + 16, 0, 16, 16), color12);
                            if (ugBackTransition > 0f)
                            {
                                Microsoft.Xna.Framework.Color color13 = color12;
                                color13.R = (byte)((float)(int)color13.R * ugBackTransition);
                                color13.G = (byte)((float)(int)color13.G * ugBackTransition);
                                color13.B = (byte)((float)(int)color13.B * ugBackTransition);
                                color13.A = (byte)((float)(int)color13.A * ugBackTransition);
                                spriteBatch.Draw(TextureAssets.Background[array2[2]].Value, new Vector2(bgStartX + num3 * num38 + 16 * num39 + num18, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num39 + num18 + 16, 0, 16, 16), color13);
                            }
                        }
                    }
                }
            }
        }
        bgTopY = (int)((float)((int)rockLayer * 16) - screenPosition.Y + 16f + 600f - 8f);
        if (rockLayer * 16.0 <= (double)(screenPosition.Y + 600f))
        {
            bgParallax = caveParallax;
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num3 + (double)screenPosition.X * bgParallax, num3) - (double)(num3 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num3 + 2;
            if (rockLayer * 16.0 + (double)screenHeight < (double)(screenPosition.Y - 16f))
            {
                bgStartY = (int)(Math.IEEERemainder(bgTopY, backgroundHeight[3]) - (double)backgroundHeight[3]);
                bgLoopsY = (screenHeight - bgStartY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            else
            {
                bgStartY = bgTopY;
                bgLoopsY = (screenHeight - bgTopY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            if (num16 * 16.0 < (double)(screenPosition.Y + 600f))
            {
                bgLoopsY = (int)(num16 * 16.0 - (double)screenPosition.Y + 600.0 - (double)bgStartY) / backgroundHeight[2];
                flag = true;
            }
            int num42 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
            if (num42 == -8)
            {
                num42 = 8;
            }
            for (int num43 = 0; num43 < bgLoops; num43++)
            {
                for (int num44 = 0; num44 < bgLoopsY; num44++)
                {
                    for (int num45 = 0; num45 < num3 / 16; num45++)
                    {
                        for (int num46 = 0; num46 < 6; num46++)
                        {
                            float num47 = bgStartY + num44 * 96 + num46 * 16 + 8;
                            int num48 = (int)(((float)(bgStartX + num3 * num43 + num45 * 16 + 8) + screenPosition.X) / 16f);
                            int num49 = (int)((num47 + screenPosition.Y) / 16f);
                            Microsoft.Xna.Framework.Color color14 = Lighting.GetColor(num48, num49);
                            if ((!ShouldDrawBackgroundTileAt(num48, num49) && color14.R != 0 && color14.G != 0 && color14.B != 0) || (color14.R <= 0 && color14.G <= 0 && color14.B <= 0) || (!WallLightAt(num48, num49) && caveParallax == 0f))
                            {
                                continue;
                            }
                            if (Lighting.NotRetro && color14.R < 230 && color14.G < 230 && color14.B < 230 && ugBackTransition == 0f)
                            {
                                if ((color14.R > num || (double)(int)color14.G > (double)num * 1.1 || (double)(int)color14.B > (double)num * 1.2) && !tile[num48, num49].active())
                                {
                                    Lighting.GetColor9Slice(num48, num49, ref slices);
                                    for (int num50 = 0; num50 < 9; num50++)
                                    {
                                        int num51 = 0;
                                        int num52 = 0;
                                        int width2 = 4;
                                        int height2 = 4;
                                        Microsoft.Xna.Framework.Color color15 = color14;
                                        Microsoft.Xna.Framework.Color color16 = color14;
                                        switch (num50)
                                        {
                                        case 0:
                                            if (!tile[num48 - 1, num49 - 1].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 1:
                                            width2 = 8;
                                            num51 = 4;
                                            if (!tile[num48, num49 - 1].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 2:
                                            num51 = 12;
                                            if (!tile[num48 + 1, num49 - 1].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 3:
                                            height2 = 8;
                                            num52 = 4;
                                            if (!tile[num48 - 1, num49].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 4:
                                            width2 = 8;
                                            height2 = 8;
                                            num51 = 4;
                                            num52 = 4;
                                            break;
                                        case 5:
                                            num51 = 12;
                                            num52 = 4;
                                            height2 = 8;
                                            if (!tile[num48 + 1, num49].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 6:
                                            num52 = 12;
                                            if (!tile[num48 - 1, num49 + 1].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 7:
                                            width2 = 8;
                                            height2 = 4;
                                            num51 = 4;
                                            num52 = 12;
                                            if (!tile[num48, num49 + 1].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        case 8:
                                            num51 = 12;
                                            num52 = 12;
                                            if (!tile[num48 + 1, num49 + 1].active())
                                            {
                                                color16 = slices[num50];
                                            }
                                            break;
                                        }
                                        color15.R = (byte)((color14.R + color16.R) / 2);
                                        color15.G = (byte)((color14.G + color16.G) / 2);
                                        color15.B = (byte)((color14.B + color16.B) / 2);
                                        color15.R = (byte)((float)(int)color15.R * num4);
                                        color15.G = (byte)((float)(int)color15.G * num5);
                                        color15.B = (byte)((float)(int)color15.B * num6);
                                        spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num51 + num42, bgStartY + backgroundHeight[array[3]] * num44 + 16 * num46 + num52) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num51 + num42 + 16, 16 * num46 + num52, width2, height2), color15);
                                        if (ugBackTransition > 0f)
                                        {
                                            Microsoft.Xna.Framework.Color color17 = color15;
                                            color17.R = (byte)((float)(int)color17.R * ugBackTransition);
                                            color17.G = (byte)((float)(int)color17.G * ugBackTransition);
                                            color17.B = (byte)((float)(int)color17.B * ugBackTransition);
                                            color17.A = (byte)((float)(int)color17.A * ugBackTransition);
                                            spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num51 + num42, bgStartY + backgroundHeight[array2[3]] * num44 + 16 * num46 + num52) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num51 + num42 + 16, 16 * num46 + num52, width2, height2), color17);
                                        }
                                    }
                                }
                                else if (color14.R > num2 || (double)(int)color14.G > (double)num2 * 1.1 || (double)(int)color14.B > (double)num2 * 1.2)
                                {
                                    Lighting.GetColor4Slice(num48, num49, ref slices);
                                    for (int num53 = 0; num53 < 4; num53++)
                                    {
                                        int num54 = 0;
                                        int num55 = 0;
                                        Microsoft.Xna.Framework.Color color18 = color14;
                                        Microsoft.Xna.Framework.Color color19 = slices[num53];
                                        switch (num53)
                                        {
                                        case 1:
                                            num54 = 8;
                                            break;
                                        case 2:
                                            num55 = 8;
                                            break;
                                        case 3:
                                            num54 = 8;
                                            num55 = 8;
                                            break;
                                        }
                                        color18.R = (byte)((color14.R + color19.R) / 2);
                                        color18.G = (byte)((color14.G + color19.G) / 2);
                                        color18.B = (byte)((color14.B + color19.B) / 2);
                                        color18.R = (byte)((float)(int)color18.R * num4);
                                        color18.G = (byte)((float)(int)color18.G * num5);
                                        color18.B = (byte)((float)(int)color18.B * num6);
                                        spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num54 + num42, bgStartY + backgroundHeight[array[3]] * num44 + 16 * num46 + num55) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num54 + num42 + 16, 16 * num46 + num55, 8, 8), color18);
                                        if (ugBackTransition > 0f)
                                        {
                                            Microsoft.Xna.Framework.Color color20 = color18;
                                            color20.R = (byte)((float)(int)color20.R * ugBackTransition);
                                            color20.G = (byte)((float)(int)color20.G * ugBackTransition);
                                            color20.B = (byte)((float)(int)color20.B * ugBackTransition);
                                            color20.A = (byte)((float)(int)color20.A * ugBackTransition);
                                            spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num54 + num42, bgStartY + backgroundHeight[array2[3]] * num44 + 16 * num46 + num55) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num54 + num42 + 16, 16 * num46 + num55, 8, 8), color20);
                                        }
                                    }
                                }
                                else
                                {
                                    color14.R = (byte)((float)(int)color14.R * num4);
                                    color14.G = (byte)((float)(int)color14.G * num5);
                                    color14.B = (byte)((float)(int)color14.B * num6);
                                    spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num42, bgStartY + backgroundHeight[array[3]] * num44 + 16 * num46) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num42 + 16, 16 * num46, 16, 16), color14);
                                    if (ugBackTransition > 0f)
                                    {
                                        Microsoft.Xna.Framework.Color color21 = color14;
                                        color21.R = (byte)((float)(int)color21.R * ugBackTransition);
                                        color21.G = (byte)((float)(int)color21.G * ugBackTransition);
                                        color21.B = (byte)((float)(int)color21.B * ugBackTransition);
                                        color21.A = (byte)((float)(int)color21.A * ugBackTransition);
                                        spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num42, bgStartY + backgroundHeight[array2[3]] * num44 + 16 * num46) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num42 + 16, 16 * num46, 16, 16), color21);
                                    }
                                }
                            }
                            else
                            {
                                color14.R = (byte)((float)(int)color14.R * num4);
                                color14.G = (byte)((float)(int)color14.G * num5);
                                color14.B = (byte)((float)(int)color14.B * num6);
                                spriteBatch.Draw(TextureAssets.Background[array[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num42, bgStartY + backgroundHeight[array[3]] * num44 + 16 * num46) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num42 + 16, 16 * num46, 16, 16), color14);
                                if (ugBackTransition > 0f)
                                {
                                    Microsoft.Xna.Framework.Color color22 = color14;
                                    color22.R = (byte)((float)(int)color22.R * ugBackTransition);
                                    color22.G = (byte)((float)(int)color22.G * ugBackTransition);
                                    color22.B = (byte)((float)(int)color22.B * ugBackTransition);
                                    color22.A = (byte)((float)(int)color22.A * ugBackTransition);
                                    spriteBatch.Draw(TextureAssets.Background[array2[3]].Value, new Vector2(bgStartX + num3 * num43 + 16 * num45 + num42, bgStartY + backgroundHeight[array2[3]] * num44 + 16 * num46) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num45 + num42 + 16, 16 * num46, 16, 16), color22);
                                }
                            }
                        }
                    }
                }
            }
            num3 = 128;
            if (flag)
            {
                bgParallax = caveParallax;
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)num3 + (double)screenPosition.X * bgParallax, num3) - (double)(num3 / 2)) - (int)vector.X;
                bgLoops = (screenWidth + (int)vector.X * 2) / num3 + 2;
                bgTopY = bgStartY + bgLoopsY * backgroundHeight[2];
                for (int num56 = 0; num56 < bgLoops; num56++)
                {
                    for (int num57 = 0; num57 < num3 / 16; num57++)
                    {
                        float num58 = bgStartX + num3 * num56 + num57 * 16 + 8;
                        float num59 = bgTopY;
                        Microsoft.Xna.Framework.Color color23 = Lighting.GetColor((int)((num58 + screenPosition.X) / 16f), (int)((screenPosition.Y + num59) / 16f));
                        color23.R = (byte)((float)(int)color23.R * num4);
                        color23.G = (byte)((float)(int)color23.G * num5);
                        color23.B = (byte)((float)(int)color23.B * num6);
                        spriteBatch.Draw(TextureAssets.Background[array[4]].Value, new Vector2(bgStartX + num3 * num56 + 16 * num57 + num42, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num57 + num42 + 16, magmaBGFrame * 16, 16, 16), color23);
                        if (ugBackTransition > 0f)
                        {
                            Microsoft.Xna.Framework.Color color24 = color23;
                            color24.R = (byte)((float)(int)color24.R * ugBackTransition);
                            color24.G = (byte)((float)(int)color24.G * ugBackTransition);
                            color24.B = (byte)((float)(int)color24.B * ugBackTransition);
                            color24.A = (byte)((float)(int)color24.A * ugBackTransition);
                            spriteBatch.Draw(TextureAssets.Background[array2[4]].Value, new Vector2(bgStartX + num3 * num56 + 16 * num57 + num42, bgTopY) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num57 + num42 + 16, magmaBGFrame * 16, 16, 16), color24);
                        }
                    }
                }
            }
        }
        bgTopY = (int)((float)((int)num16 * 16) - screenPosition.Y + 16f + 600f) - 8;
        if (num16 * 16.0 <= (double)(screenPosition.Y + 600f))
        {
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)num3 + (double)screenPosition.X * bgParallax, num3) - (double)(num3 / 2)) - (int)vector.X;
            bgLoops = (screenWidth + (int)vector.X * 2) / num3 + 2;
            if (num16 * 16.0 + (double)screenHeight < (double)(screenPosition.Y - 16f))
            {
                bgStartY = (int)(Math.IEEERemainder(bgTopY, backgroundHeight[2]) - (double)backgroundHeight[2]);
                bgLoopsY = (screenHeight - bgStartY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            else
            {
                bgStartY = bgTopY;
                bgLoopsY = (screenHeight - bgTopY + (int)vector.Y * 2) / backgroundHeight[2] + 1;
            }
            num = (int)((double)num * 1.5);
            num2 = (int)((double)num2 * 1.5);
            int num60 = (int)(float)Math.Round(0f - (float)Math.IEEERemainder((float)bgStartX + screenPosition.X, 16.0));
            if (num60 == -8)
            {
                num60 = 8;
            }
            for (int num61 = 0; num61 < bgLoops; num61++)
            {
                for (int num62 = 0; num62 < bgLoopsY; num62++)
                {
                    for (int num63 = 0; num63 < num3 / 16; num63++)
                    {
                        for (int num64 = 0; num64 < 6; num64++)
                        {
                            float num65 = bgStartY + num62 * 96 + num64 * 16 + 8;
                            int num66 = (int)(((float)(bgStartX + num3 * num61 + num63 * 16 + 8) + screenPosition.X) / 16f);
                            int num67 = (int)((num65 + screenPosition.Y) / 16f);
                            Microsoft.Xna.Framework.Color color25 = Lighting.GetColor(num66, num67);
                            if ((!ShouldDrawBackgroundTileAt(num66, num67) && color25.R != 0 && color25.G != 0 && color25.B != 0) || (color25.R <= 0 && color25.G <= 0 && color25.B <= 0) || (!WallLightAt(num66, num67) && caveParallax == 0f))
                            {
                                continue;
                            }
                            if (Lighting.NotRetro && color25.R < 230 && color25.G < 230 && color25.B < 230)
                            {
                                if ((color25.R > num || (double)(int)color25.G > (double)num * 1.1 || (double)(int)color25.B > (double)num * 1.2) && !tile[num66, num67].active())
                                {
                                    Lighting.GetColor9Slice(num66, num67, ref slices);
                                    for (int num68 = 0; num68 < 9; num68++)
                                    {
                                        int num69 = 0;
                                        int num70 = 0;
                                        int width3 = 4;
                                        int height3 = 4;
                                        Microsoft.Xna.Framework.Color color26 = color25;
                                        Microsoft.Xna.Framework.Color color27 = color25;
                                        switch (num68)
                                        {
                                        case 0:
                                            if (!tile[num66 - 1, num67 - 1].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 1:
                                            width3 = 8;
                                            num69 = 4;
                                            if (!tile[num66, num67 - 1].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 2:
                                            num69 = 12;
                                            if (!tile[num66 + 1, num67 - 1].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 3:
                                            height3 = 8;
                                            num70 = 4;
                                            if (!tile[num66 - 1, num67].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 4:
                                            width3 = 8;
                                            height3 = 8;
                                            num69 = 4;
                                            num70 = 4;
                                            break;
                                        case 5:
                                            num69 = 12;
                                            num70 = 4;
                                            height3 = 8;
                                            if (!tile[num66 + 1, num67].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 6:
                                            num70 = 12;
                                            if (!tile[num66 - 1, num67 + 1].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 7:
                                            width3 = 8;
                                            height3 = 4;
                                            num69 = 4;
                                            num70 = 12;
                                            if (!tile[num66, num67 + 1].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        case 8:
                                            num69 = 12;
                                            num70 = 12;
                                            if (!tile[num66 + 1, num67 + 1].active())
                                            {
                                                color27 = slices[num68];
                                            }
                                            break;
                                        }
                                        color26.R = (byte)((color25.R + color27.R) / 2);
                                        color26.G = (byte)((color25.G + color27.G) / 2);
                                        color26.B = (byte)((color25.B + color27.B) / 2);
                                        color26.R = (byte)((float)(int)color26.R * num4);
                                        color26.G = (byte)((float)(int)color26.G * num5);
                                        color26.B = (byte)((float)(int)color26.B * num6);
                                        spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num3 * num61 + 16 * num63 + num69 + num60, bgStartY + backgroundHeight[2] * num62 + 16 * num64 + num70) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num63 + num69 + num60 + 16, 16 * num64 + backgroundHeight[2] * magmaBGFrame + num70, width3, height3), color26, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                                    }
                                }
                                else if (color25.R > num2 || (double)(int)color25.G > (double)num2 * 1.1 || (double)(int)color25.B > (double)num2 * 1.2)
                                {
                                    Lighting.GetColor4Slice(num66, num67, ref slices);
                                    for (int num71 = 0; num71 < 4; num71++)
                                    {
                                        int num72 = 0;
                                        int num73 = 0;
                                        Microsoft.Xna.Framework.Color color28 = color25;
                                        Microsoft.Xna.Framework.Color color29 = slices[num71];
                                        switch (num71)
                                        {
                                        case 1:
                                            num72 = 8;
                                            break;
                                        case 2:
                                            num73 = 8;
                                            break;
                                        case 3:
                                            num72 = 8;
                                            num73 = 8;
                                            break;
                                        }
                                        color28.R = (byte)((color25.R + color29.R) / 2);
                                        color28.G = (byte)((color25.G + color29.G) / 2);
                                        color28.B = (byte)((color25.B + color29.B) / 2);
                                        color28.R = (byte)((float)(int)color28.R * num4);
                                        color28.G = (byte)((float)(int)color28.G * num5);
                                        color28.B = (byte)((float)(int)color28.B * num6);
                                        spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num3 * num61 + 16 * num63 + num72 + num60, bgStartY + backgroundHeight[2] * num62 + 16 * num64 + num73) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num63 + num72 + num60 + 16, 16 * num64 + backgroundHeight[2] * magmaBGFrame + num73, 8, 8), color28, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                                    }
                                }
                                else
                                {
                                    color25.R = (byte)((float)(int)color25.R * num4);
                                    color25.G = (byte)((float)(int)color25.G * num5);
                                    color25.B = (byte)((float)(int)color25.B * num6);
                                    spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num3 * num61 + 16 * num63 + num60, bgStartY + backgroundHeight[2] * num62 + 16 * num64) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num63 + num60 + 16, 16 * num64 + backgroundHeight[2] * magmaBGFrame, 16, 16), color25, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                                }
                            }
                            else
                            {
                                color25.R = (byte)((float)(int)color25.R * num4);
                                color25.G = (byte)((float)(int)color25.G * num5);
                                color25.B = (byte)((float)(int)color25.B * num6);
                                spriteBatch.Draw(TextureAssets.Background[array[5]].Value, new Vector2(bgStartX + num3 * num61 + 16 * num63 + num60, bgStartY + backgroundHeight[2] * num62 + 16 * num64) + vector, new Microsoft.Xna.Framework.Rectangle(16 * num63 + num60 + 16, 16 * num64 + backgroundHeight[2] * magmaBGFrame, 16, 16), color25, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                            }
                        }
                    }
                }
            }
        }
        Lighting.GlobalBrightness = globalBrightness;
        TimeLogger.DrawTime(3, stopwatch.Elapsed.TotalMilliseconds);
    }
 
    private static bool ShouldDrawBackgroundTileAt(int i, int j)
    {
        if (tile[i, j] == null)
        {
            tile[i, j] = new Tile();
        }
        if (caveParallax != 0f)
        {
            if (tile[i - 1, j] == null)
            {
                tile[i - 1, j] = new Tile();
            }
            if (tile[i + 1, j] == null)
            {
                tile[i + 1, j] = new Tile();
            }
            if (WallLightAt(i, j) || WallLightAt(i - 1, j) || WallLightAt(i + 1, j))
            {
                return true;
            }
        }
        else if (WallLightAt(i, j))
        {
            return true;
        }
        return false;
    }
 
    public static bool WallLightAt(int i, int j)
    {
        return WallLightAt(i, j, ShouldShowInvisibleWalls());
    }
 
    public static bool WallLightAt(int i, int j, bool showInvisibleWalls)
    {
        Tile tile = Main.tile[i, j];
        if (!wallLight[tile.wall])
        {
            if (!showInvisibleWalls)
            {
                return tile.invisibleWall();
            }
            return false;
        }
        return true;
    }
 
    protected void RenderBackground()
    {
        if (drawToScreen)
        {
            return;
        }
        base.GraphicsDevice.SetRenderTarget(backWaterTarget);
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
        spriteBatch.Begin();
        tileBatch.Begin();
        try
        {
            DrawWaters(isBackground: true);
        }
        catch
        {
        }
        tileBatch.End();
        spriteBatch.End();
        base.GraphicsDevice.SetRenderTarget(null);
        base.GraphicsDevice.SetRenderTarget(backgroundTarget);
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
        spriteBatch.Begin();
        tileBatch.Begin();
        if (ignoreErrors)
        {
            try
            {
                DrawBackground();
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
            }
        }
        else
        {
            DrawBackground();
        }
        TimeLogger.DetailedDrawReset();
        tileBatch.End();
        spriteBatch.End();
        TimeLogger.DetailedDrawTime(33);
        base.GraphicsDevice.SetRenderTarget(null);
    }
 
    protected void DrawToMap()
    {
        if (!mapEnabled)
        {
            return;
        }
        int num = maxTilesX / textureMaxWidth;
        int num2 = maxTilesY / textureMaxHeight;
        for (int i = 0; i <= num; i++)
        {
            for (int j = 0; j <= num2; j++)
            {
                if (!checkMap(i, j))
                {
                    return;
                }
            }
        }
        if (clearMap)
        {
            for (int k = 0; k <= num; k++)
            {
                for (int l = 0; l <= num2; l++)
                {
                    base.GraphicsDevice.SetRenderTarget(mapTarget[k, l]);
                    base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
                    base.GraphicsDevice.SetRenderTarget(null);
                }
            }
            clearMap = false;
        }
        int num3 = -1;
        int num4 = -1;
        bool flag = false;
        int num5 = 0;
        int num6 = mapMinY;
        int num7 = mapMinY;
        int num8 = mapMaxY;
        int num9 = mapMaxY;
        int num10 = 1;
        if (mapMinY / textureMaxHeight != mapMaxY / textureMaxHeight)
        {
            num8 = textureMaxHeight;
            num7 = textureMaxHeight;
            num10 = 2;
        }
        for (int m = 0; m < num10; m++)
        {
            switch (m)
            {
            case 0:
                mapMinY = num6;
                mapMaxY = num8;
                break;
            case 1:
                mapMinY = num7;
                mapMaxY = num9;
                break;
            }
            if (mapMinX < 0)
            {
                mapMinX = 0;
            }
            if (mapMinX >= maxTilesX)
            {
                mapMinX = maxTilesX - 1;
            }
            if (mapMinY < 0)
            {
                mapMinY = 0;
            }
            if (mapMinY >= maxTilesY)
            {
                mapMinY = maxTilesY - 1;
            }
            for (int n = mapMinX; n < mapMaxX; n++)
            {
                for (int num11 = mapMinY; num11 < mapMaxY; num11++)
                {
                    MapTile mapTile = Map[n, num11];
                    if (!mapTile.IsChanged || mapTarget[n / textureMaxWidth, num11 / textureMaxHeight].IsContentLost)
                    {
                        continue;
                    }
                    num5++;
                    if (num5 >= maxMapUpdates)
                    {
                        continue;
                    }
                    if (loadMap)
                    {
                        loadMapLastX = n;
                    }
                    Map.ConsumeUpdate(n, num11);
                    int num12 = n / textureMaxWidth;
                    int num13 = num11 / textureMaxHeight;
                    if (num12 != num3 || num13 != num4)
                    {
                        num3 = num12;
                        num4 = num13;
                        if (flag)
                        {
                            spriteBatch.End();
                            base.GraphicsDevice.SetRenderTarget(null);
                        }
                        flag = true;
                        base.GraphicsDevice.SetRenderTarget(mapTarget[num12, num13]);
                        spriteBatch.Begin();
                    }
                    int num14 = n - num12 * textureMaxWidth;
                    int num15 = num11 - num13 * textureMaxHeight;
                    Microsoft.Xna.Framework.Color mapTileXnaColor = MapHelper.GetMapTileXnaColor(ref mapTile);
                    int num16 = 1;
                    int num17 = 1;
                    int num18 = num11 + 1;
                    while (num18 < mapMaxY)
                    {
                        MapTile other;
                        MapTile mapTile2 = (other = Map[n, num18]);
                        if (!mapTile2.IsChanged || !mapTile.Equals(ref other) || num18 / textureMaxHeight != num13)
                        {
                            break;
                        }
                        Map.ConsumeUpdate(n, num18);
                        num16++;
                        num18++;
                        num11++;
                    }
                    if (num16 == 1)
                    {
                        for (num18 = n + 1; num18 < mapMaxX; num18++)
                        {
                            MapTile other;
                            MapTile mapTile2 = (other = Map[num18, num11]);
                            if (!mapTile2.IsChanged || !mapTile.Equals(ref other) || num18 / textureMaxWidth != num12)
                            {
                                break;
                            }
                            Map.ConsumeUpdate(num18, num11);
                            num17++;
                        }
                    }
                    spriteBatch.Draw(TextureAssets.MagicPixel.Value, new Vector2(num14, num15), new Microsoft.Xna.Framework.Rectangle(0, 0, num17, num16), mapTileXnaColor, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                }
            }
        }
        for (int num19 = 0; num19 < MapHelper.numUpdateTile; num19++)
        {
            int num20 = MapHelper.updateTileX[num19];
            int num21 = MapHelper.updateTileY[num19];
            MapTile mapTile3 = Map[num20, num21];
            if (!mapTile3.IsChanged)
            {
                continue;
            }
            Map.ConsumeUpdate(num20, num21);
            int num22 = num20 / textureMaxWidth;
            int num23 = num21 / textureMaxHeight;
            if (num22 != num3 || num23 != num4)
            {
                num3 = num22;
                num4 = num23;
                if (flag)
                {
                    spriteBatch.End();
                    base.GraphicsDevice.SetRenderTarget(null);
                }
                flag = true;
                base.GraphicsDevice.SetRenderTarget(mapTarget[num22, num23]);
                spriteBatch.Begin();
            }
            int num24 = num20 - num22 * textureMaxWidth;
            int num25 = num21 - num23 * textureMaxHeight;
            Microsoft.Xna.Framework.Color mapTileXnaColor2 = MapHelper.GetMapTileXnaColor(ref mapTile3);
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, new Vector2(num24, num25), new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1), mapTileXnaColor2, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
        MapHelper.numUpdateTile = 0;
        if (flag)
        {
            spriteBatch.End();
            base.GraphicsDevice.SetRenderTarget(null);
        }
        mapReady = true;
        loadMapLastX = 0;
        loadMap = false;
        loadMapLock = false;
    }
 
    protected void DrawToMap_Section(int secX, int secY)
    {
        Stopwatch stopwatch = Stopwatch.StartNew();
        Microsoft.Xna.Framework.Color[] mapColorCacheArray = _mapColorCacheArray;
        int num = secX * 200;
        int num2 = num + 200;
        int num3 = secY * 150;
        int num4 = num3 + 150;
        int num5 = num / textureMaxWidth;
        int num6 = num3 / textureMaxHeight;
        int num7 = num % textureMaxWidth;
        int num8 = num3 % textureMaxHeight;
        if (!checkMap(num5, num6))
        {
            return;
        }
        int num9 = 0;
        _ = Microsoft.Xna.Framework.Color.Transparent;
        for (int i = num3; i < num4; i++)
        {
            for (int j = num; j < num2; j++)
            {
                MapTile mapTile = Map[j, i];
                mapColorCacheArray[num9] = MapHelper.GetMapTileXnaColor(ref mapTile);
                num9++;
            }
        }
        try
        {
            base.GraphicsDevice.SetRenderTarget(mapTarget[num5, num6]);
        }
        catch (ObjectDisposedException)
        {
            initMap[num5, num6] = false;
            return;
        }
        spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
        double totalMilliseconds = stopwatch.Elapsed.TotalMilliseconds;
        mapSectionTexture.SetData(mapColorCacheArray, 0, mapColorCacheArray.Length);
        _ = stopwatch.Elapsed.TotalMilliseconds;
        totalMilliseconds = stopwatch.Elapsed.TotalMilliseconds;
        spriteBatch.Draw(mapSectionTexture, new Vector2(num7, num8), Microsoft.Xna.Framework.Color.White);
        spriteBatch.End();
        base.GraphicsDevice.SetRenderTarget(null);
        _ = stopwatch.Elapsed.TotalMilliseconds;
        stopwatch.Stop();
    }
 
    public static string ValueToCoins(long value)
    {
        long num = value;
        long num2 = 0L;
        long num3 = 0L;
        long num4 = 0L;
        long num5 = 0L;
        while (num >= 1000000)
        {
            num -= 1000000;
            num2++;
        }
        while (num >= 10000)
        {
            num -= 10000;
            num3++;
        }
        while (num >= 100)
        {
            num -= 100;
            num4++;
        }
        num5 = num;
        string text = "";
        if (num2 > 0)
        {
            text += string.Format("{0} {1} ", num2, Language.GetTextValue("Currency.Platinum").ToLower());
        }
        if (num3 > 0)
        {
            text += string.Format("{0} {1} ", num3, Language.GetTextValue("Currency.Gold").ToLower());
        }
        if (num4 > 0)
        {
            text += string.Format("{0} {1} ", num4, Language.GetTextValue("Currency.Silver").ToLower());
        }
        if (num5 > 0)
        {
            text += string.Format("{0} {1} ", num5, Language.GetTextValue("Currency.Copper").ToLower());
        }
        if (text.Length > 0)
        {
            text = text.Substring(0, text.Length - 1);
        }
        return text;
    }
 
    private static void UpdateMinimapAnchors()
    {
        int num = 240;
        int num2 = 240;
        _minimapTopRightAnchorOffsetTowardsLeft = 292;
        _minimapTopRightAnchorOffsetTowardsBottom = 90;
        _minimapTopRightAnchorOffsetTowardsLeft = (int)((float)(52 + num / 2) + MapScale * (float)num / 2f);
        _minimapTopRightAnchorOffsetTowardsBottom = (int)((float)(90 + num2 / 2) - MapScale * (float)num2 / 2f);
        _minimapTopRightAnchorOffsetTowardsLeft = 52 + (int)(240f * MapScale);
        _minimapTopRightAnchorOffsetTowardsBottom = 90;
    }
 
    protected void DrawMap(GameTime gameTime)
    {
        string text = "";
        if (!mapEnabled || !mapReady)
        {
            return;
        }
        float num = 0f;
        float num2 = 0f;
        float num3 = num;
        float num4 = num2;
        float num5 = 2f;
        byte b = byte.MaxValue;
        _ = maxTilesX / textureMaxWidth;
        int num6 = maxTilesY / textureMaxHeight;
        float num7 = Lighting.OffScreenTiles;
        float num8 = Lighting.OffScreenTiles;
        float num9 = maxTilesX - Lighting.OffScreenTiles - 1;
        float num10 = maxTilesY - Lighting.OffScreenTiles - 42;
        float num11 = 0f;
        float num12 = 0f;
        num7 = 10f;
        num8 = 10f;
        num9 = maxTilesX - 10;
        num10 = maxTilesY - 10;
        for (int i = 0; i < mapTarget.GetLength(0); i++)
        {
            for (int j = 0; j < mapTarget.GetLength(1); j++)
            {
                if (mapTarget[i, j] != null)
                {
                    if (mapTarget[i, j].IsContentLost && !mapWasContentLost[i, j])
                    {
                        mapWasContentLost[i, j] = true;
                        refreshMap = true;
                        clearMap = true;
                    }
                    else if (!mapTarget[i, j].IsContentLost && mapWasContentLost[i, j])
                    {
                        mapWasContentLost[i, j] = false;
                    }
                }
            }
        }
        num = 200f;
        num2 = 300f;
        float num13 = 0f;
        float num14 = 0f;
        float num15 = num9 - 1f;
        float num16 = num10 - 1f;
        num5 = (mapFullscreen ? mapFullscreenScale : ((mapStyle != 1) ? mapOverlayScale : mapMinimapScale));
        bool flag = false;
        float mapScale = MapScale;
        float num17 = 1f / mapScale;
        int num18 = mouseX;
        int num19 = mouseY;
        Matrix uIScaleMatrix = UIScaleMatrix;
        Matrix transformMatrix = uIScaleMatrix;
        Matrix transformMatrix2 = uIScaleMatrix;
        Matrix matrix = Matrix.CreateScale(mapScale);
        CoinLossRevengeSystem.RevengeMarker revengeMarker = null;
        int num20 = -1;
        if (mapStyle != 1)
        {
            transformMatrix = Matrix.Identity;
        }
        if (mapFullscreen)
        {
            transformMatrix = Matrix.Identity;
        }
        if (!mapFullscreen && mapStyle == 1)
        {
            transformMatrix *= matrix;
            transformMatrix2 *= matrix;
        }
        if (!mapFullscreen)
        {
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix);
            if (num5 > 1f)
            {
                flag = true;
            }
        }
        if (mapFullscreen)
        {
            if (mouseLeft && base.IsActive && !CaptureManager.Instance.UsingMap)
            {
                if (mouseLeftRelease)
                {
                    grabMapX = mouseX;
                    grabMapY = mouseY;
                }
                else
                {
                    float num21 = (float)mouseX - grabMapX;
                    float num22 = (float)mouseY - grabMapY;
                    grabMapX = mouseX;
                    grabMapY = mouseY;
                    num21 *= 0.06255f;
                    num22 *= 0.06255f;
                    mapFullscreenPos.X -= num21 * (16f / mapFullscreenScale);
                    mapFullscreenPos.Y -= num22 * (16f / mapFullscreenScale);
                }
            }
            player[myPlayer].mouseInterface = true;
            float num23 = (float)screenWidth / (float)maxTilesX * 0.599f;
            if (mapFullscreenScale < num23)
            {
                mapFullscreenScale = num23;
            }
            if (mapFullscreenScale > 31.2f)
            {
                mapFullscreenScale = 31.18f;
            }
            num5 = mapFullscreenScale;
            b = byte.MaxValue;
            if (mapFullscreenPos.X < num7)
            {
                mapFullscreenPos.X = num7;
            }
            if (mapFullscreenPos.X > num9)
            {
                mapFullscreenPos.X = num9;
            }
            if (mapFullscreenPos.Y < num8)
            {
                mapFullscreenPos.Y = num8;
            }
            if (mapFullscreenPos.Y > num10)
            {
                mapFullscreenPos.Y = num10;
            }
            float num24 = mapFullscreenPos.X;
            float num25 = mapFullscreenPos.Y;
            if (resetMapFull)
            {
                resetMapFull = false;
                num24 = (screenPosition.X + (float)(screenWidth / 2)) / 16f;
                num25 = (screenPosition.Y + (float)(screenHeight / 2)) / 16f;
                mapFullscreenPos.X = num24;
                mapFullscreenPos.Y = num25;
            }
            num24 *= num5;
            num25 *= num5;
            num = 0f - num24 + (float)(screenWidth / 2);
            num2 = 0f - num25 + (float)(screenHeight / 2);
            num += num7 * num5;
            num2 += num8 * num5;
            float num26 = maxTilesX / 840;
            num26 *= mapFullscreenScale;
            float num27 = num;
            float num28 = num2;
            float num29 = TextureAssets.Map.Width();
            float num30 = TextureAssets.Map.Height();
            if (maxTilesX == 8400)
            {
                num26 *= 0.999f;
                num27 -= 40.6f * num26;
                num28 = num2 - 5f * num26;
                num29 -= 8.045f;
                num29 *= num26;
                num30 += 0.12f;
                num30 *= num26;
                if ((double)num26 < 1.2)
                {
                    num30 += 1f;
                }
            }
            else if (maxTilesX == 6400)
            {
                num26 *= 1.09f;
                num27 -= 38.8f * num26;
                num28 = num2 - 3.85f * num26;
                num29 -= 13.6f;
                num29 *= num26;
                num30 -= 6.92f;
                num30 *= num26;
                if ((double)num26 < 1.2)
                {
                    num30 += 2f;
                }
            }
            else if (maxTilesX == 6300)
            {
                num26 *= 1.09f;
                num27 -= 39.8f * num26;
                num28 = num2 - 4.08f * num26;
                num29 -= 26.69f;
                num29 *= num26;
                num30 -= 6.92f;
                num30 *= num26;
                if ((double)num26 < 1.2)
                {
                    num30 += 2f;
                }
            }
            else if (maxTilesX == 4200)
            {
                num26 *= 0.998f;
                num27 -= 37.3f * num26;
                num28 -= 1.7f * num26;
                num29 -= 16f;
                num29 *= num26;
                num30 -= 8.31f;
                num30 *= num26;
            }
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise);
            flag = true;
            DrawMapFullscreenBackground(screenPosition, screenWidth, screenHeight);
            Microsoft.Xna.Framework.Rectangle destinationRectangle = new Microsoft.Xna.Framework.Rectangle((int)num27, (int)num28, (int)num29, (int)num30);
            spriteBatch.Draw(TextureAssets.Map.Value, destinationRectangle, Microsoft.Xna.Framework.Color.White);
            if (mouseLeft && mouseLeftRelease)
            {
                double totalSeconds = gameTime.TotalGameTime.TotalSeconds;
                if (totalSeconds - _lastPingMouseDownTime < 0.5 && Vector2.Distance(MouseScreen, _lastPingMousePosition) < 2f)
                {
                    TriggerPing((MouseScreen - new Vector2(num - 10f * num5, num2 - 10f * num5)) / num5);
                }
                _lastPingMouseDownTime = totalSeconds;
                _lastPingMousePosition = MouseScreen;
            }
            if (num5 < 1f)
            {
                spriteBatch.End();
                spriteBatch.Begin();
                flag = false;
            }
        }
        else if (mapStyle == 1)
        {
            UpdateMinimapAnchors();
            miniMapWidth = 240;
            miniMapHeight = 240;
            miniMapX = screenWidth - _minimapTopRightAnchorOffsetTowardsLeft;
            miniMapY = _minimapTopRightAnchorOffsetTowardsBottom;
            miniMapX = (int)((float)miniMapX * num17);
            miniMapY = (int)((float)miniMapY * num17);
            mouseX = (int)((float)mouseX * num17);
            mouseY = (int)((float)mouseY * num17);
            _ = (float)miniMapHeight / (float)maxTilesY;
            if ((double)mapMinimapScale < 0.2)
            {
                mapMinimapScale = 0.2f;
            }
            if (mapMinimapScale > 3f)
            {
                mapMinimapScale = 3f;
            }
            if ((double)mapMinimapAlpha < 0.01)
            {
                mapMinimapAlpha = 0.01f;
            }
            if (mapMinimapAlpha > 1f)
            {
                mapMinimapAlpha = 1f;
            }
            num5 = mapMinimapScale;
            b = (byte)(255f * mapMinimapAlpha);
            num = miniMapX;
            num2 = miniMapY;
            num3 = num;
            num4 = num2;
            float num31 = (screenPosition.X + (float)(PlayerInput.RealScreenWidth / 2)) / 16f;
            float num32 = (screenPosition.Y + (float)(PlayerInput.RealScreenHeight / 2)) / 16f;
            num11 = (0f - (num31 - (float)(int)((screenPosition.X + (float)(PlayerInput.RealScreenWidth / 2)) / 16f))) * num5;
            num12 = (0f - (num32 - (float)(int)((screenPosition.Y + (float)(PlayerInput.RealScreenHeight / 2)) / 16f))) * num5;
            num15 = (float)miniMapWidth / num5;
            num16 = (float)miniMapHeight / num5;
            num13 = (float)(int)num31 - num15 / 2f;
            num14 = (float)(int)num32 - num16 / 2f;
            _ = (float)maxTilesY + num14;
            float num33 = num3 - 6f;
            float num34 = num4 - 6f;
            MinimapFrameManagerInstance.DrawTo(spriteBatch, new Vector2(num33 + 10f, num34 + 10f));
        }
        else if (mapStyle == 2)
        {
            float num35 = (float)screenWidth / (float)maxTilesX;
            if (mapOverlayScale < num35)
            {
                mapOverlayScale = num35;
            }
            if (mapOverlayScale > 16f * GameViewMatrix.Zoom.X)
            {
                mapOverlayScale = 16f * GameViewMatrix.Zoom.X;
            }
            if ((double)mapOverlayAlpha < 0.01)
            {
                mapOverlayAlpha = 0.01f;
            }
            if (mapOverlayAlpha > 1f)
            {
                mapOverlayAlpha = 1f;
            }
            num5 = mapOverlayScale;
            b = (byte)(255f * mapOverlayAlpha);
            _ = maxTilesX;
            _ = maxTilesY;
            float num36 = (screenPosition.X + (float)(screenWidth / 2)) / 16f;
            float num37 = (screenPosition.Y + (float)(screenHeight / 2)) / 16f;
            num36 *= num5;
            float num38 = num37 * num5;
            num = 0f - num36 + (float)(screenWidth / 2);
            num2 = 0f - num38 + (float)(screenHeight / 2);
            num += num7 * num5;
            num2 += num8 * num5;
        }
        if (mapStyle == 1 && !mapFullscreen)
        {
            if (num13 < num7)
            {
                num -= (num13 - num7) * num5;
            }
            if (num14 < num8)
            {
                num2 -= (num14 - num8) * num5;
            }
        }
        num15 = num13 + num15;
        num16 = num14 + num16;
        if (num13 > num7)
        {
            num7 = num13;
        }
        if (num14 > num8)
        {
            num8 = num14;
        }
        if (num15 < num9)
        {
            num9 = num15;
        }
        if (num16 < num10)
        {
            num10 = num16;
        }
        float num39 = (float)textureMaxWidth * num5;
        float num40 = (float)textureMaxHeight * num5;
        float num41 = num;
        float num42 = 0f;
        for (int k = 0; k <= 4; k++)
        {
            if (!((float)((k + 1) * textureMaxWidth) > num7) || !((float)(k * textureMaxWidth) < num7 + num9))
            {
                continue;
            }
            for (int l = 0; l <= num6; l++)
            {
                if ((float)((l + 1) * textureMaxHeight) > num8 && (float)(l * textureMaxHeight) < num8 + num10)
                {
                    float num43 = num + (float)(int)((float)k * num39);
                    float num44 = num2 + (float)(int)((float)l * num40);
                    float num45 = k * textureMaxWidth;
                    float num46 = l * textureMaxHeight;
                    float num47 = 0f;
                    float num48 = 0f;
                    if (num45 < num7)
                    {
                        num47 = num7 - num45;
                        num43 = num;
                    }
                    else
                    {
                        num43 -= num7 * num5;
                    }
                    if (num46 < num8)
                    {
                        num48 = num8 - num46;
                        num44 = num2;
                    }
                    else
                    {
                        num44 -= num8 * num5;
                    }
                    num43 = num41;
                    float num49 = textureMaxWidth;
                    float num50 = textureMaxHeight;
                    float num51 = (k + 1) * textureMaxWidth;
                    float num52 = (l + 1) * textureMaxHeight;
                    if (num51 >= num9)
                    {
                        num49 -= num51 - num9;
                    }
                    if (num52 >= num10)
                    {
                        num50 -= num52 - num10;
                    }
                    num43 += num11;
                    num44 += num12;
                    if (num49 > num47)
                    {
                        Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle((int)num47, (int)num48, (int)num49 - (int)num47, (int)num50 - (int)num48);
                        spriteBatch.Draw(mapTarget[k, l], new Vector2(num43, num44), value, new Microsoft.Xna.Framework.Color(b, b, b, b), 0f, default(Vector2), num5, SpriteEffects.None, 0f);
                    }
                    num42 = (float)((int)num49 - (int)num47) * num5;
                }
                if (l == num6)
                {
                    num41 += num42;
                }
            }
        }
        if (flag)
        {
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix);
        }
        if (!mapFullscreen)
        {
            if (mapStyle == 2)
            {
                float num53 = (num5 * 0.2f * 2f + 1f) / 3f;
                if (num53 > 1f)
                {
                    num53 = 1f;
                }
                num53 *= UIScale;
                MapIcons.Draw(Vector2.Zero, new Vector2(num - 10f * num5, num2 - 10f * num5), null, num5, num53, ref text);
                revengeMarker = NPC.RevengeManager.DrawMapIcons(spriteBatch, Vector2.Zero, new Vector2(num - 10f * num5, num2 - 10f * num5), null, num5, num53, ref text);
                DrawMiscMapIcons(spriteBatch, Vector2.Zero, new Vector2(num - 10f * num5, num2 - 10f * num5), null, num5, num53, ref text);
                spriteBatch.End();
                if (revengeMarker != null)
                {
                    spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, uIScaleMatrix);
                    try
                    {
                        revengeMarker.UseMouseOver(spriteBatch, ref text, num53);
                    }
                    catch (Exception e)
                    {
                        TimeLogger.DrawException(e);
                    }
                    spriteBatch.End();
                }
                spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix);
                try
                {
                    for (int m = 0; m < 200; m++)
                    {
                        if (npc[m].active && npc[m].townNPC)
                        {
                            int headIndexSafe = TownNPCProfiles.GetHeadIndexSafe(npc[m]);
                            if (headIndexSafe > 0)
                            {
                                SpriteEffects dir = SpriteEffects.None;
                                if (npc[m].direction > 0)
                                {
                                    dir = SpriteEffects.FlipHorizontally;
                                }
                                float num54 = (npc[m].position.X + (float)(npc[m].width / 2)) / 16f * num5;
                                float num55 = (npc[m].position.Y + (float)(npc[m].height / 2)) / 16f * num5;
                                num54 += num;
                                num55 += num2;
                                num54 -= 10f * num5;
                                num55 -= 10f * num5;
                                DrawNPCHeadFriendly(npc[m], b, num53, dir, headIndexSafe, num54, num55);
                            }
                        }
                        if (!npc[m].active || npc[m].GetBossHeadTextureIndex() == -1)
                        {
                            continue;
                        }
                        float bossHeadRotation = npc[m].GetBossHeadRotation();
                        SpriteEffects bossHeadSpriteEffects = npc[m].GetBossHeadSpriteEffects();
                        Vector2 vector = npc[m].Center + new Vector2(0f, npc[m].gfxOffY);
                        if (npc[m].type == 134)
                        {
                            Vector2 center = npc[m].Center;
                            int num56 = 1;
                            int num57 = (int)npc[m].ai[0];
                            while (num56 < 15 && npc[num57].active && npc[num57].type >= 134 && npc[num57].type <= 136)
                            {
                                num56++;
                                center += npc[num57].Center;
                                num57 = (int)npc[num57].ai[0];
                            }
                            center /= (float)num56;
                            vector = center;
                        }
                        int bossHeadTextureIndex = npc[m].GetBossHeadTextureIndex();
                        float num58 = vector.X / 16f * num5;
                        float num59 = vector.Y / 16f * num5;
                        num58 += num;
                        num59 += num2;
                        num58 -= 10f * num5;
                        num59 -= 10f * num5;
                        DrawNPCHeadBoss(npc[m], b, num53, bossHeadRotation, bossHeadSpriteEffects, bossHeadTextureIndex, num58, num59);
                    }
                }
                catch (Exception e2)
                {
                    TimeLogger.DrawException(e2);
                }
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix);
                for (int n = 0; n < 255; n++)
                {
                    if (player[n].active && !player[n].dead && n != myPlayer && ((!player[myPlayer].hostile && !player[n].hostile) || (player[myPlayer].team == player[n].team && player[n].team != 0) || n == myPlayer))
                    {
                        float num60 = (player[n].position.X + (float)(player[n].width / 2)) / 16f * num5;
                        float num61 = player[n].position.Y / 16f * num5;
                        num60 += num;
                        num61 += num2;
                        num60 -= 6f;
                        num61 -= 2f;
                        num61 -= 2f - num5 / 5f * 2f;
                        num60 -= 10f * num5;
                        num61 -= 10f * num5;
                        Microsoft.Xna.Framework.Color playerHeadBordersColor = GetPlayerHeadBordersColor(player[n]);
                        MapPlayerRenderer.DrawPlayerHead(Camera, player[n], new Vector2(num60, num61), (float)(int)b / 255f, num53, playerHeadBordersColor);
                    }
                }
                spriteBatch.End();
                spriteBatch.Begin();
            }
            if (mapStyle == 1)
            {
                float num62 = (num5 * 0.25f * 2f + 1f) / 3f;
                if (num62 > 1f)
                {
                    num62 = 1f;
                }
                MapIcons.Draw(new Vector2(num13, num14), new Vector2(num3 + num11, num4 + num12), new Microsoft.Xna.Framework.Rectangle(miniMapX, miniMapY, miniMapWidth, miniMapHeight), num5, num62, ref text);
                revengeMarker = NPC.RevengeManager.DrawMapIcons(spriteBatch, new Vector2(num13, num14), new Vector2(num3 + num11, num4 + num12), new Microsoft.Xna.Framework.Rectangle(miniMapX, miniMapY, miniMapWidth, miniMapHeight), num5, num62, ref text);
                DrawMiscMapIcons(spriteBatch, new Vector2(num13, num14), new Vector2(num3 + num11, num4 + num12), new Microsoft.Xna.Framework.Rectangle(miniMapX, miniMapY, miniMapWidth, miniMapHeight), num5, num62, ref text);
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix2);
                for (int num63 = 0; num63 < 200; num63++)
                {
                    if (npc[num63].active && npc[num63].townNPC)
                    {
                        int headIndexSafe2 = TownNPCProfiles.GetHeadIndexSafe(npc[num63]);
                        if (headIndexSafe2 > 0)
                        {
                            SpriteEffects dir2 = SpriteEffects.None;
                            if (npc[num63].direction > 0)
                            {
                                dir2 = SpriteEffects.FlipHorizontally;
                            }
                            float num64 = ((npc[num63].position.X + (float)npc[num63].width / 2f) / 16f - num13) * num5;
                            float num65 = ((npc[num63].position.Y + npc[num63].gfxOffY + (float)npc[num63].height / 2f) / 16f - num14) * num5;
                            num64 += num3;
                            num65 += num4;
                            num65 -= 2f * num5 / 5f;
                            num64 += num11;
                            num65 += num12;
                            if (num64 > (float)(miniMapX + 12) && num64 < (float)(miniMapX + miniMapWidth - 16) && num65 > (float)(miniMapY + 10) && num65 < (float)(miniMapY + miniMapHeight - 14))
                            {
                                float num66 = num64 - (float)(TextureAssets.NpcHead[headIndexSafe2].Width() / 2) * num62;
                                float num67 = num65 - (float)(TextureAssets.NpcHead[headIndexSafe2].Height() / 2) * num62;
                                float num68 = num66 + (float)TextureAssets.NpcHead[headIndexSafe2].Width() * num62;
                                float num69 = num67 + (float)TextureAssets.NpcHead[headIndexSafe2].Height() * num62;
                                if ((float)mouseX >= num66 && (float)mouseX <= num68 && (float)mouseY >= num67 && (float)mouseY <= num69)
                                {
                                    text = npc[num63].FullName;
                                }
                                DrawNPCHeadFriendly(npc[num63], b, num62, dir2, headIndexSafe2, num64, num65);
                            }
                        }
                    }
                    if (!npc[num63].active || npc[num63].GetBossHeadTextureIndex() == -1)
                    {
                        continue;
                    }
                    float bossHeadRotation2 = npc[num63].GetBossHeadRotation();
                    SpriteEffects bossHeadSpriteEffects2 = npc[num63].GetBossHeadSpriteEffects();
                    Vector2 vector2 = npc[num63].Center + new Vector2(0f, npc[num63].gfxOffY);
                    if (npc[num63].type == 134)
                    {
                        Vector2 center2 = npc[num63].Center;
                        int num70 = 1;
                        int num71 = (int)npc[num63].ai[0];
                        while (num70 < 15 && npc[num71].active && npc[num71].type >= 134 && npc[num71].type <= 136)
                        {
                            num70++;
                            center2 += npc[num71].Center;
                            num71 = (int)npc[num71].ai[0];
                        }
                        center2 /= (float)num70;
                        vector2 = center2;
                    }
                    int bossHeadTextureIndex2 = npc[num63].GetBossHeadTextureIndex();
                    float num72 = (vector2.X / 16f - num13) * num5;
                    float num73 = (vector2.Y / 16f - num14) * num5;
                    num72 += num3;
                    num73 += num4;
                    num73 -= 2f * num5 / 5f;
                    num72 += num11;
                    num73 += num12;
                    if (num72 > (float)(miniMapX + 12) && num72 < (float)(miniMapX + miniMapWidth - 16) && num73 > (float)(miniMapY + 10) && num73 < (float)(miniMapY + miniMapHeight - 14))
                    {
                        float num74 = num72 - (float)(TextureAssets.NpcHeadBoss[bossHeadTextureIndex2].Width() / 2) * num62;
                        float num75 = num73 - (float)(TextureAssets.NpcHeadBoss[bossHeadTextureIndex2].Height() / 2) * num62;
                        float num76 = num74 + (float)TextureAssets.NpcHeadBoss[bossHeadTextureIndex2].Width() * num62;
                        float num77 = num75 + (float)TextureAssets.NpcHeadBoss[bossHeadTextureIndex2].Height() * num62;
                        if ((float)mouseX >= num74 && (float)mouseX <= num76 && (float)mouseY >= num75 && (float)mouseY <= num77)
                        {
                            text = npc[num63].GivenOrTypeName;
                        }
                        DrawNPCHeadBoss(npc[num63], b, num62, bossHeadRotation2, bossHeadSpriteEffects2, bossHeadTextureIndex2, num72, num73);
                    }
                }
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix2);
                for (int num78 = 0; num78 < 255; num78++)
                {
                    if (!player[num78].active || ((player[myPlayer].hostile || player[num78].hostile) && (player[myPlayer].team != player[num78].team || player[num78].team == 0) && num78 != myPlayer))
                    {
                        continue;
                    }
                    float num79 = ((player[num78].position.X + (float)(player[num78].width / 2)) / 16f - num13) * num5;
                    float num80 = ((player[num78].position.Y + player[num78].gfxOffY + (float)(player[num78].height / 2)) / 16f - num14) * num5;
                    num79 += num3;
                    num80 += num4;
                    num79 -= 6f;
                    num80 -= 6f;
                    num80 -= 2f - num5 / 5f * 2f;
                    num79 += num11;
                    num80 += num12;
                    if (!player[num78].dead && num79 > (float)(miniMapX + 6) && num79 < (float)(miniMapX + miniMapWidth - 16) && num80 > (float)(miniMapY + 6) && num80 < (float)(miniMapY + miniMapHeight - 14))
                    {
                        Microsoft.Xna.Framework.Color playerHeadBordersColor2 = GetPlayerHeadBordersColor(player[num78]);
                        MapPlayerRenderer.DrawPlayerHead(Camera, player[num78], new Vector2(num79, num80), (float)(int)b / 255f, num62, playerHeadBordersColor2);
                        if (num78 != myPlayer)
                        {
                            float num81 = num79 + 4f - 14f * num62;
                            float num82 = num80 + 2f - 14f * num62;
                            float num83 = num81 + 28f * num62;
                            float num84 = num82 + 28f * num62;
                            if ((float)mouseX >= num81 && (float)mouseX <= num83 && (float)mouseY >= num82 && (float)mouseY <= num84)
                            {
                                text = player[num78].name;
                            }
                        }
                    }
                    if (!player[num78].showLastDeath)
                    {
                        continue;
                    }
                    num79 = (player[num78].lastDeathPostion.X / 16f - num13) * num5;
                    num80 = (player[num78].lastDeathPostion.Y / 16f - num14) * num5;
                    num79 += num3;
                    num80 += num4;
                    num80 -= 2f - num5 / 5f * 2f;
                    num79 += num11;
                    num80 += num12;
                    if (num79 > (float)(miniMapX + 8) && num79 < (float)(miniMapX + miniMapWidth - 18) && num80 > (float)(miniMapY + 8) && num80 < (float)(miniMapY + miniMapHeight - 16))
                    {
                        spriteBatch.Draw(TextureAssets.MapDeath.Value, new Vector2(num79, num80), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.MapDeath.Width(), TextureAssets.MapDeath.Height()), Microsoft.Xna.Framework.Color.White, 0f, new Vector2((float)TextureAssets.MapDeath.Width() * 0.5f, (float)TextureAssets.MapDeath.Height() * 0.5f), num62, SpriteEffects.None, 0f);
                        float num85 = num79 + 4f - 14f * num62;
                        float num86 = num80 + 2f - 14f * num62;
                        num85 -= 4f;
                        num86 -= 4f;
                        float num87 = num85 + 28f * num62;
                        float num88 = num86 + 28f * num62;
                        if ((float)mouseX >= num85 && (float)mouseX <= num87 && (float)mouseY >= num86 && (float)mouseY <= num88)
                        {
                            num20 = num78;
                        }
                    }
                }
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, transformMatrix2);
                MinimapFrameManagerInstance.DrawForeground(spriteBatch);
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, uIScaleMatrix);
                if (num20 != -1)
                {
                    TimeSpan timeSpan = DateTime.Now - player[num20].lastDeathTime;
                    text = Language.GetTextValue("Game.PlayerDeathTime", player[num20].name, Lang.LocalizedDuration(timeSpan, abbreviated: false, showAllAvailableUnits: false));
                }
                else
                {
                    revengeMarker?.UseMouseOver(spriteBatch, ref text);
                }
            }
        }
        if (mapFullscreen)
        {
            int num89 = (int)((0f - num + (float)mouseX) / num5 + num7);
            int num90 = (int)((0f - num2 + (float)mouseY) / num5 + num8);
            bool flag2 = false;
            if ((float)num89 < num7)
            {
                flag2 = true;
            }
            if ((float)num89 >= num9)
            {
                flag2 = true;
            }
            if ((float)num90 < num8)
            {
                flag2 = true;
            }
            if ((float)num90 >= num10)
            {
                flag2 = true;
            }
            if (!flag2 && Map[num89, num90].Light > 40)
            {
                int type = Map[num89, num90].Type;
                int num91 = MapHelper.tileLookup[21];
                int num92 = MapHelper.tileLookup[441];
                int num93 = MapHelper.tileOptionCounts[21];
                int num94 = MapHelper.tileLookup[467];
                int num95 = MapHelper.tileLookup[468];
                int num96 = MapHelper.tileOptionCounts[467];
                int num97 = MapHelper.tileLookup[88];
                int num98 = MapHelper.tileOptionCounts[88];
                LocalizedText[] chestType = Lang.chestType;
                LocalizedText[] chestType2 = Lang.chestType2;
                if (type >= num91 && type < num91 + num93)
                {
                    Tile tile = Main.tile[num89, num90];
                    if (tile != null)
                    {
                        int num99 = num89;
                        int num100 = num90;
                        if (tile.frameX % 36 != 0)
                        {
                            num99--;
                        }
                        if (tile.frameY % 36 != 0)
                        {
                            num100--;
                        }
                        text = DrawMap_FindChestName(chestType, tile, num99, num100);
                    }
                }
                else if (type >= num94 && type < num94 + num96)
                {
                    Tile tile2 = Main.tile[num89, num90];
                    if (tile2 != null)
                    {
                        int num101 = num89;
                        int num102 = num90;
                        if (tile2.frameX % 36 != 0)
                        {
                            num101--;
                        }
                        if (tile2.frameY % 36 != 0)
                        {
                            num102--;
                        }
                        text = DrawMap_FindChestName(chestType2, tile2, num101, num102);
                    }
                }
                else if (type >= num92 && type < num92 + num93)
                {
                    Tile tile3 = Main.tile[num89, num90];
                    if (tile3 != null)
                    {
                        int num103 = num89;
                        int num104 = num90;
                        if (tile3.frameX % 36 != 0)
                        {
                            num103--;
                        }
                        if (tile3.frameY % 36 != 0)
                        {
                            num104--;
                        }
                        text = chestType[tile3.frameX / 36].Value;
                    }
                }
                else if (type >= num95 && type < num95 + num96)
                {
                    Tile tile4 = Main.tile[num89, num90];
                    if (tile4 != null)
                    {
                        int num105 = num89;
                        int num106 = num90;
                        if (tile4.frameX % 36 != 0)
                        {
                            num105--;
                        }
                        if (tile4.frameY % 36 != 0)
                        {
                            num106--;
                        }
                        text = chestType2[tile4.frameX / 36].Value;
                    }
                }
                else if (type >= num97 && type < num97 + num98)
                {
                    Tile tile5 = Main.tile[num89, num90];
                    if (tile5 != null)
                    {
                        int num107 = num90;
                        int x = num89 - tile5.frameX % 54 / 18;
                        if (tile5.frameY % 36 != 0)
                        {
                            num107--;
                        }
                        int num108 = Chest.FindChest(x, num107);
                        text = ((num108 < 0) ? Lang.dresserType[0].Value : ((!(chest[num108].name != "")) ? Lang.dresserType[tile5.frameX / 54].Value : (Lang.dresserType[tile5.frameX / 54].Value + ": " + chest[num108].name)));
                    }
                }
                else
                {
                    text = Lang.GetMapObjectName(type);
                }
            }
            float num109 = (num5 * 0.25f * 2f + 1f) / 3f;
            if (num109 > 1f)
            {
                num109 = 1f;
            }
            num109 = 1f;
            num109 = UIScale;
            revengeMarker = NPC.RevengeManager.DrawMapIcons(spriteBatch, Vector2.Zero, new Vector2(num - 10f * num5, num2 - 10f * num5), null, num5, num109, ref text);
            DrawMiscMapIcons(spriteBatch, Vector2.Zero, new Vector2(num - 10f * num5, num2 - 10f * num5), null, num5, num109, ref text);
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
            for (int num110 = 0; num110 < 200; num110++)
            {
                if (npc[num110].active && npc[num110].townNPC)
                {
                    int headIndexSafe3 = TownNPCProfiles.GetHeadIndexSafe(npc[num110]);
                    if (headIndexSafe3 > 0)
                    {
                        SpriteEffects dir3 = SpriteEffects.None;
                        if (npc[num110].direction > 0)
                        {
                            dir3 = SpriteEffects.FlipHorizontally;
                        }
                        float num111 = (npc[num110].position.X + (float)(npc[num110].width / 2)) / 16f * num5;
                        float num112 = (npc[num110].position.Y + npc[num110].gfxOffY + (float)(npc[num110].height / 2)) / 16f * num5;
                        num111 += num;
                        num112 += num2;
                        num111 -= 10f * num5;
                        num112 -= 10f * num5;
                        float num113 = num111 - (float)(TextureAssets.NpcHead[headIndexSafe3].Width() / 2) * num109;
                        float num114 = num112 - (float)(TextureAssets.NpcHead[headIndexSafe3].Height() / 2) * num109;
                        float num115 = num113 + (float)TextureAssets.NpcHead[headIndexSafe3].Width() * num109;
                        float num116 = num114 + (float)TextureAssets.NpcHead[headIndexSafe3].Height() * num109;
                        if ((float)mouseX >= num113 && (float)mouseX <= num115 && (float)mouseY >= num114 && (float)mouseY <= num116)
                        {
                            text = npc[num110].FullName;
                        }
                        DrawNPCHeadFriendly(npc[num110], b, num109, dir3, headIndexSafe3, num111, num112);
                    }
                }
                if (!npc[num110].active || npc[num110].GetBossHeadTextureIndex() == -1)
                {
                    continue;
                }
                float bossHeadRotation3 = npc[num110].GetBossHeadRotation();
                SpriteEffects bossHeadSpriteEffects3 = npc[num110].GetBossHeadSpriteEffects();
                Vector2 vector3 = npc[num110].Center + new Vector2(0f, npc[num110].gfxOffY);
                if (npc[num110].type == 134)
                {
                    Vector2 center3 = npc[num110].Center;
                    int num117 = 1;
                    int num118 = (int)npc[num110].ai[0];
                    while (num117 < 15 && npc[num118].active && npc[num118].type >= 134 && npc[num118].type <= 136)
                    {
                        num117++;
                        center3 += npc[num118].Center;
                        num118 = (int)npc[num118].ai[0];
                    }
                    center3 /= (float)num117;
                    vector3 = center3;
                }
                int bossHeadTextureIndex3 = npc[num110].GetBossHeadTextureIndex();
                float num119 = vector3.X / 16f * num5;
                float num120 = vector3.Y / 16f * num5;
                num119 += num;
                num120 += num2;
                num119 -= 10f * num5;
                num120 -= 10f * num5;
                DrawNPCHeadBoss(npc[num110], b, num109, bossHeadRotation3, bossHeadSpriteEffects3, bossHeadTextureIndex3, num119, num120);
                float num121 = num119 - (float)(TextureAssets.NpcHeadBoss[bossHeadTextureIndex3].Width() / 2) * num109;
                float num122 = num120 - (float)(TextureAssets.NpcHeadBoss[bossHeadTextureIndex3].Height() / 2) * num109;
                float num123 = num121 + (float)TextureAssets.NpcHeadBoss[bossHeadTextureIndex3].Width() * num109;
                float num124 = num122 + (float)TextureAssets.NpcHeadBoss[bossHeadTextureIndex3].Height() * num109;
                if ((float)mouseX >= num121 && (float)mouseX <= num123 && (float)mouseY >= num122 && (float)mouseY <= num124)
                {
                    text = npc[num110].GivenOrTypeName;
                }
            }
            bool flag3 = false;
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
            for (int num125 = 0; num125 < 255; num125++)
            {
                if (player[num125].active && ((!player[myPlayer].hostile && !player[num125].hostile) || (player[myPlayer].team == player[num125].team && player[num125].team != 0) || num125 == myPlayer) && player[num125].showLastDeath && DrawPlayerDeathMarker(num, num2, num5, num13, num14, num109, num125))
                {
                    num20 = num125;
                }
            }
            if (num20 != -1)
            {
                TimeSpan timeSpan2 = DateTime.Now - player[num20].lastDeathTime;
                text = Language.GetTextValue("Game.PlayerDeathTime", player[num20].name, Lang.LocalizedDuration(timeSpan2, abbreviated: false, showAllAvailableUnits: false));
            }
            else if (revengeMarker != null)
            {
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, uIScaleMatrix);
                revengeMarker.UseMouseOver(spriteBatch, ref text, num109);
                spriteBatch.End();
                spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
            }
            for (int num126 = 0; num126 < 255; num126++)
            {
                if (!player[num126].active || ((player[myPlayer].hostile || player[num126].hostile) && (player[myPlayer].team != player[num126].team || player[num126].team == 0) && num126 != myPlayer))
                {
                    continue;
                }
                float num127 = ((player[num126].position.X + (float)(player[num126].width / 2)) / 16f - num13) * num5;
                float num128 = ((player[num126].position.Y + player[num126].gfxOffY + (float)(player[num126].height / 2)) / 16f - num14) * num5;
                num127 += num;
                num128 += num2;
                num127 -= 6f;
                num128 -= 2f;
                num128 -= 2f - num5 / 5f * 2f;
                num127 -= 10f * num5;
                num128 -= 10f * num5;
                float num129 = num127 + 4f - 14f * num109;
                float num130 = num128 + 2f - 14f * num109;
                float num131 = num129 + 28f * num109;
                float num132 = num130 + 28f * num109;
                if (player[num126].dead)
                {
                    continue;
                }
                Microsoft.Xna.Framework.Color playerHeadBordersColor3 = GetPlayerHeadBordersColor(player[num126]);
                MapPlayerRenderer.DrawPlayerHead(Camera, player[num126], new Vector2(num127, num128), (float)(int)b / 255f, num109, playerHeadBordersColor3);
                if (!((float)mouseX >= num129) || !((float)mouseX <= num131) || !((float)mouseY >= num130) || !((float)mouseY <= num132))
                {
                    continue;
                }
                text = player[num126].name;
                if (num126 != myPlayer && player[myPlayer].team > 0 && player[myPlayer].team == player[num126].team && netMode == 1 && player[myPlayer].HasUnityPotion() && !flag3 && !cancelWormHole)
                {
                    flag3 = true;
                    if (!unityMouseOver)
                    {
                        SoundEngine.PlaySound(12);
                    }
                    unityMouseOver = true;
                    playerHeadBordersColor3 = OurFavoriteColor;
                    MapPlayerRenderer.DrawPlayerHead(Camera, player[num126], new Vector2(num127, num128), 1f, num109 + 0.5f, playerHeadBordersColor3);
                    text = Language.GetTextValue("Game.TeleportTo", player[num126].name);
                    if (mouseLeft && mouseLeftRelease)
                    {
                        mouseLeftRelease = false;
                        mapFullscreen = false;
                        player[myPlayer].UnityTeleport(player[num126].position);
                        player[myPlayer].TakeUnityPotion();
                    }
                }
            }
            cancelWormHole = false;
            MapIcons.Draw(Vector2.Zero, new Vector2(num - 10f * num5, num2 - 10f * num5), null, num5, num109, ref text);
            if (!flag3 && unityMouseOver)
            {
                unityMouseOver = false;
            }
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerStateForCursor, DepthStencilState.None, RasterizerState.CullCounterClockwise, null, UIScaleMatrix);
            PlayerInput.SetZoom_UI();
            int num133 = 10;
            int num134 = screenHeight - 40;
            if (showFrameRate)
            {
                num134 -= 15;
            }
            int num135 = 0;
            int num136 = 130;
            if (mouseX >= num133 && mouseX <= num133 + 32 && mouseY >= num134 && mouseY <= num134 + 30)
            {
                num136 = 255;
                num135 += 4;
                player[myPlayer].mouseInterface = true;
                if (mouseLeft && mouseLeftRelease)
                {
                    SoundEngine.PlaySound(10);
                    mapFullscreen = false;
                }
            }
            spriteBatch.Draw(TextureAssets.MapIcon[num135].Value, new Vector2(num133, num134), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.MapIcon[num135].Width(), TextureAssets.MapIcon[num135].Height()), new Microsoft.Xna.Framework.Color(num136, num136, num136, num136), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            DrawCursor(DrawThickCursor());
        }
        mouseX = num18;
        mouseY = num19;
        float t = 3f;
        Utils.Swap(ref t, ref inventoryScale);
        if (text != "")
        {
            MouseText(text, 0, 0);
        }
        Utils.Swap(ref t, ref inventoryScale);
        spriteBatch.End();
        try
        {
            if (num13 < num7)
            {
                num += (num13 - num7) * num5;
            }
            if (num14 < num8)
            {
                num2 += (num14 - num8) * num5;
            }
            if (mapFullscreen && Main.OnPostFullscreenMapDraw != null)
            {
                Main.OnPostFullscreenMapDraw(new Vector2(num, num2), num5);
            }
        }
        catch (Exception e3)
        {
            TimeLogger.DrawException(e3);
        }
        spriteBatch.Begin();
        PlayerInput.SetZoom_Unscaled();
        TimeLogger.DetailedDrawTime(9);
    }
 
    private static void DrawMapFullscreenBackground(Vector2 screenPosition, int screenWidth, int screenHeight)
    {
        Asset<Texture2D> val = TextureAssets.MapBGs[0];
        int num = -1;
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.White;
        if (tile[(int)(player[myPlayer].Center.X / 16f), (int)(player[myPlayer].Center.Y / 16f)] == null)
        {
            return;
        }
        int wall = tile[(int)(player[myPlayer].Center.X / 16f), (int)(player[myPlayer].Center.Y / 16f)].wall;
        if (screenPosition.Y > (float)((maxTilesY - 232) * 16))
        {
            num = 2;
        }
        else if (player[myPlayer].ZoneDungeon)
        {
            num = 4;
        }
        else if (wall == 87)
        {
            num = 13;
        }
        else if ((double)screenPosition.Y > worldSurface * 16.0)
        {
            switch (wall)
            {
            case 86:
            case 108:
                num = 15;
                break;
            case 180:
            case 184:
                num = 16;
                break;
            case 178:
            case 183:
                num = 17;
                break;
            case 62:
            case 263:
                num = 18;
                break;
            default:
                num = ((!player[myPlayer].ZoneGlowshroom) ? ((!player[myPlayer].ZoneCorrupt) ? ((!player[myPlayer].ZoneCrimson) ? ((!player[myPlayer].ZoneHallow) ? ((!player[myPlayer].ZoneSnow) ? ((!player[myPlayer].ZoneJungle) ? ((!player[myPlayer].ZoneDesert) ? ((!player[myPlayer].ZoneRockLayerHeight) ? 1 : 31) : 14) : 12) : 3) : ((!player[myPlayer].ZoneDesert) ? ((!player[myPlayer].ZoneSnow) ? 21 : 35) : 41)) : ((!player[myPlayer].ZoneDesert) ? ((!player[myPlayer].ZoneSnow) ? 23 : 34) : 40)) : ((!player[myPlayer].ZoneDesert) ? ((!player[myPlayer].ZoneSnow) ? 22 : 33) : 39)) : 20);
                break;
            }
        }
        else if (player[myPlayer].ZoneGlowshroom)
        {
            num = 19;
        }
        else
        {
            color = ColorOfTheSkies;
            int num2 = (int)((screenPosition.X + (float)(screenWidth / 2)) / 16f);
            if (player[myPlayer].ZoneSkyHeight)
            {
                num = 32;
            }
            else if (player[myPlayer].ZoneCorrupt)
            {
                num = ((!player[myPlayer].ZoneDesert) ? 5 : 36);
            }
            else if (player[myPlayer].ZoneCrimson)
            {
                num = ((!player[myPlayer].ZoneDesert) ? 6 : 37);
            }
            else if (player[myPlayer].ZoneHallow)
            {
                num = ((!player[myPlayer].ZoneDesert) ? 7 : 38);
            }
            else if ((double)(screenPosition.Y / 16f) < worldSurface + 10.0 && (num2 < 380 || num2 > maxTilesX - 380))
            {
                num = 10;
            }
            else if (player[myPlayer].ZoneSnow)
            {
                num = 11;
            }
            else if (player[myPlayer].ZoneJungle)
            {
                num = 8;
            }
            else if (player[myPlayer].ZoneDesert)
            {
                num = 9;
            }
            else if (bloodMoon)
            {
                color *= 2f;
                num = 25;
            }
            else if (player[myPlayer].ZoneGraveyard)
            {
                num = 26;
            }
        }
        if (num > -1)
        {
            val = TextureAssets.MapBGs[num];
        }
        spriteBatch.Draw(val.Value, new Microsoft.Xna.Framework.Rectangle(0, 0, screenWidth, screenHeight), color);
    }
 
    private static bool DrawPlayerDeathMarker(float X, float Y, float scale, float left, float top, float headScale, int i)
    {
        float num = (player[i].lastDeathPostion.X / 16f - left) * scale;
        float num2 = (player[i].lastDeathPostion.Y / 16f - top) * scale;
        num += X;
        num2 += Y;
        num2 -= 2f - scale / 5f * 2f;
        num -= 10f * scale;
        num2 -= 10f * scale;
        spriteBatch.Draw(TextureAssets.MapDeath.Value, new Vector2(num, num2), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.MapDeath.Width(), TextureAssets.MapDeath.Height()), Microsoft.Xna.Framework.Color.White, 0f, new Vector2((float)TextureAssets.MapDeath.Width() * 0.5f, (float)TextureAssets.MapDeath.Height() * 0.5f), headScale, SpriteEffects.None, 0f);
        float num3 = num + 4f - 14f * headScale;
        float num4 = num2 + 2f - 14f * headScale;
        float num5 = num3 + 28f * headScale;
        float num6 = num4 + 28f * headScale;
        if ((float)mouseX >= num3 && (float)mouseX <= num5 && (float)mouseY >= num4)
        {
            return (float)mouseY <= num6;
        }
        return false;
    }
 
    private void DrawMiscMapIcons(SpriteBatch spriteBatch, Vector2 mapTopLeft, Vector2 mapX2Y2AndOff, Microsoft.Xna.Framework.Rectangle? mapRect, float mapScale, float drawScale, ref string mouseTextString)
    {
        DrawMapIcons_PotionOfReturnHomePosition(spriteBatch, mapTopLeft, mapX2Y2AndOff, mapRect, mapScale, drawScale, ref mouseTextString);
        DrawMapIcons_PotionOfReturnAppearAfterUsePosition(spriteBatch, mapTopLeft, mapX2Y2AndOff, mapRect, mapScale, drawScale, ref mouseTextString);
        DrawMapIcons_LastGolfballHit(spriteBatch, mapTopLeft, mapX2Y2AndOff, mapRect, mapScale, drawScale, ref mouseTextString);
    }
 
    private void DrawMapIcons_PotionOfReturnAppearAfterUsePosition(SpriteBatch spriteBatch, Vector2 mapTopLeft, Vector2 mapX2Y2AndOff, Microsoft.Xna.Framework.Rectangle? mapRect, float mapScale, float drawScale, ref string mouseTextString)
    {
        Vector2? potionOfReturnOriginalUsePosition = LocalPlayer.PotionOfReturnOriginalUsePosition;
        if (!potionOfReturnOriginalUsePosition.HasValue)
        {
            return;
        }
        Vector2 vec = (potionOfReturnOriginalUsePosition + new Vector2(0f, -LocalPlayer.height / 2)).Value / 16f - mapTopLeft;
        vec *= mapScale;
        vec += mapX2Y2AndOff;
        vec = vec.Floor();
        if (!mapRect.HasValue || mapRect.Value.Contains(vec.ToPoint()))
        {
            Texture2D value = TextureAssets.Extra[173].Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame();
            spriteBatch.Draw(value, vec, rectangle, Microsoft.Xna.Framework.Color.White, 0f, rectangle.Size() / 2f, drawScale, SpriteEffects.None, 0f);
            if (Utils.CenteredRectangle(vec, rectangle.Size() * drawScale).Contains(MouseScreen.ToPoint()))
            {
                mouseTextString = Language.GetTextValue("GameUI.PotionOfReturnExitPortal");
                _ = MouseScreen + new Vector2(-28f) + new Vector2(4f, 0f);
            }
        }
    }
 
    private void DrawMapIcons_PotionOfReturnHomePosition(SpriteBatch spriteBatch, Vector2 mapTopLeft, Vector2 mapX2Y2AndOff, Microsoft.Xna.Framework.Rectangle? mapRect, float mapScale, float drawScale, ref string mouseTextString)
    {
        Vector2? potionOfReturnHomePosition = LocalPlayer.PotionOfReturnHomePosition;
        if (!potionOfReturnHomePosition.HasValue)
        {
            return;
        }
        Vector2 vec = (potionOfReturnHomePosition + new Vector2(0f, -LocalPlayer.height / 2)).Value / 16f - mapTopLeft;
        vec *= mapScale;
        vec += mapX2Y2AndOff;
        vec = vec.Floor();
        if (!mapRect.HasValue || mapRect.Value.Contains(vec.ToPoint()))
        {
            Texture2D value = TextureAssets.Extra[175].Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame();
            spriteBatch.Draw(value, vec, rectangle, Microsoft.Xna.Framework.Color.White, 0f, rectangle.Size() / 2f, drawScale, SpriteEffects.None, 0f);
            if (Utils.CenteredRectangle(vec, rectangle.Size() * drawScale).Contains(MouseScreen.ToPoint()))
            {
                mouseTextString = Language.GetTextValue("GameUI.PotionOfReturnHomePortal");
                _ = MouseScreen + new Vector2(-28f) + new Vector2(4f, 0f);
            }
        }
    }
 
    private void DrawMapIcons_LastGolfballHit(SpriteBatch spriteBatch, Vector2 mapTopLeft, Vector2 mapX2Y2AndOff, Microsoft.Xna.Framework.Rectangle? mapRect, float mapScale, float drawScale, ref string mouseTextString)
    {
        Projectile lastHitBall = LocalGolfState.GetLastHitBall();
        if (lastHitBall == null)
        {
            return;
        }
        Vector2 vec = lastHitBall.Center / 16f - mapTopLeft;
        vec *= mapScale;
        vec += mapX2Y2AndOff;
        vec = vec.Floor();
        if (!mapRect.HasValue || mapRect.Value.Contains(vec.ToPoint()))
        {
            Texture2D value = TextureAssets.Extra[176].Value;
            Microsoft.Xna.Framework.Rectangle rectangle = value.Frame();
            spriteBatch.Draw(value, vec, rectangle, Microsoft.Xna.Framework.Color.White, 0f, rectangle.Size() / 2f, drawScale, SpriteEffects.None, 0f);
            Microsoft.Xna.Framework.Rectangle rectangle2 = Utils.CenteredRectangle(vec, rectangle.Size() * drawScale);
            LoadProjectile(lastHitBall.type);
            value = TextureAssets.Projectile[lastHitBall.type].Value;
            rectangle = value.Frame();
            spriteBatch.Draw(value, vec, rectangle, Microsoft.Xna.Framework.Color.White, 0f, rectangle.Size() / 2f, drawScale, SpriteEffects.None, 0f);
            if (rectangle2.Contains(MouseScreen.ToPoint()))
            {
                mouseTextString = lastHitBall.Name;
                _ = MouseScreen + new Vector2(-28f) + new Vector2(4f, 0f);
            }
        }
    }
 
    public static void TriggerPing(Vector2 position)
    {
        if (!dedServ)
        {
            Pings.Add(position);
            if (netMode == 1)
            {
                NetManager.Instance.SendToServer(NetPingModule.Serialize(position));
            }
        }
    }
 
    private static void DrawNPCHeadFriendly(Entity theNPC, byte alpha, float headScale, SpriteEffects dir, int townHeadId, float x, float y)
    {
        TownNPCHeadRenderer.DrawWithOutlines(theNPC, townHeadId, new Vector2(x, y), new Microsoft.Xna.Framework.Color(alpha, alpha, alpha, alpha), 0f, headScale, dir);
    }
 
    private static void DrawNPCHeadBoss(Entity theNPC, byte alpha, float headScale, float rotation, SpriteEffects effects, int bossHeadId, float x, float y)
    {
        BossNPCHeadRenderer.DrawWithOutlines(theNPC, bossHeadId, new Vector2(x, y), new Microsoft.Xna.Framework.Color(alpha, alpha, alpha, alpha), rotation, headScale, effects);
    }
 
    private static void DrawWithOutlines(Entity entity, Texture2D tex, Vector2 position, Microsoft.Xna.Framework.Rectangle? rect, Microsoft.Xna.Framework.Color color, float rotation, Vector2 origin, float scale, SpriteEffects effects)
    {
        float num = 2f * scale;
        Microsoft.Xna.Framework.Color white = Microsoft.Xna.Framework.Color.White;
        int colorOnlyShaderIndex = ContentSamples.CommonlyUsedContentSamples.ColorOnlyShaderIndex;
        DrawData value = new DrawData(tex, position, rect, color, rotation, origin, scale, effects);
        GameShaders.Armor.Apply(colorOnlyShaderIndex, entity, value);
        Microsoft.Xna.Framework.Color black = Microsoft.Xna.Framework.Color.Black;
        black *= (float)(int)color.A / 255f;
        black *= (float)(int)color.A / 255f;
        Microsoft.Xna.Framework.Color color2 = white;
        color2 *= (float)(int)color.A / 255f;
        color2 *= (float)(int)color.A / 255f;
        int num2 = 2;
        Vector2 vector;
        for (int i = -num2; i <= num2; i++)
        {
            for (int j = -num2; j <= num2; j++)
            {
                if (Math.Abs(i) + Math.Abs(j) == num2)
                {
                    vector = new Vector2((float)i * num, (float)j * num).RotatedBy(rotation);
                    spriteBatch.Draw(tex, position + vector, rect, black, rotation, origin, scale, effects, 0f);
                }
            }
        }
        num2 = 1;
        vector = Vector2.Zero;
        for (int k = -num2; k <= num2; k++)
        {
            for (int l = -num2; l <= num2; l++)
            {
                if (Math.Abs(k) + Math.Abs(l) == num2)
                {
                    vector = new Vector2((float)k * num, (float)l * num).RotatedBy(rotation);
                    spriteBatch.Draw(tex, position + vector, rect, color2, rotation, origin, scale, effects, 0f);
                }
            }
        }
        pixelShader.CurrentTechnique.Passes[0].Apply();
        spriteBatch.Draw(tex, position, rect, color, rotation, origin, scale, effects, 0f);
    }
 
    public static Microsoft.Xna.Framework.Color GetPlayerHeadBordersColor(Player plr)
    {
        if (plr.ghost || plr.dead)
        {
            return Microsoft.Xna.Framework.Color.Transparent;
        }
        if (plr.whoAmI == myPlayer)
        {
            return teamColor[plr.team];
        }
        if (plr.hostile && (plr.team != LocalPlayer.team || plr.team == 0))
        {
            return Microsoft.Xna.Framework.Color.Transparent;
        }
        return teamColor[plr.team];
    }
 
    private static string DrawMap_FindChestName(LocalizedText[] chestNames, Tile chestTile, int x, int y, int fullTileWidth = 36)
    {
        int num = Chest.FindChestByGuessing(x, y);
        if (num < 0)
        {
            return chestNames[0].Value;
        }
        if (chest[num].name != "")
        {
            return string.Concat(chestNames[chestTile.frameX / fullTileWidth], ": ", chest[num].name);
        }
        return chestNames[chestTile.frameX / fullTileWidth].Value;
    }
 
    public void DrawSimpleSurfaceBackground(Vector2 areaPosition, int areaWidth, int areaHeight)
    {
        float num = (float)(worldSurface + 1.0) * 16f;
        float num2 = Math.Min(areaPosition.Y + (float)areaHeight, num) - areaPosition.Y;
        float y = areaPosition.Y;
        float num3 = areaPosition.Y + num2;
        Vector4 vector = ColorOfTheSkies.ToVector4();
        Vector4 value = new Microsoft.Xna.Framework.Color(53, 43, 243).ToVector4() * vector;
        Vector4 value2 = new Microsoft.Xna.Framework.Color(132, 170, 248).ToVector4() * vector;
        Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color(Vector4.Lerp(value, value2, y / num));
        Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color(Vector4.Lerp(value, value2, num3 / num));
        VertexColors colors = default(VertexColors);
        colors.TopLeftColor = color;
        colors.TopRightColor = color;
        colors.BottomLeftColor = color2;
        colors.BottomRightColor = color2;
        tileBatch.Draw(TextureAssets.BlackTile.Value, new Vector4(0f, 0f, areaWidth, num2), colors);
        float num4 = (float)areaHeight - num2;
        if (num4 > 0f)
        {
            colors.TopLeftColor = Microsoft.Xna.Framework.Color.Black;
            colors.TopRightColor = Microsoft.Xna.Framework.Color.Black;
            colors.BottomLeftColor = Microsoft.Xna.Framework.Color.Black;
            colors.BottomRightColor = Microsoft.Xna.Framework.Color.Black;
            tileBatch.Draw(TextureAssets.BlackTile.Value, new Vector4(0f, num2, areaWidth, num4), colors);
        }
    }
 
    public void DrawCapture(Microsoft.Xna.Framework.Rectangle area, CaptureSettings settings)
    {
        float[] array = bgAlphaFrontLayer;
        bgAlphaFrontLayer = new float[array.Length];
        float[] array2 = bgAlphaFarBackLayer;
        bgAlphaFarBackLayer = new float[array2.Length];
        UpdateBGVisibility_BackLayer(settings.Biome.BackgroundIndex, 1f);
        UpdateBGVisibility_FrontLayer(settings.Biome.BackgroundIndex, 1f);
        float[] array3 = liquidAlpha.ToArray();
        int holyTileCount = SceneMetrics.HolyTileCount;
        SceneMetrics.HolyTileCount = ((settings.Biome.BackgroundIndex == 6) ? SceneMetrics.HallowTileMax : 0);
        int num = offScreenRange;
        offScreenRange = 0;
        SpriteViewMatrix gameViewMatrix = GameViewMatrix;
        GameViewMatrix = new SpriteViewMatrix(base.GraphicsDevice);
        Rasterizer = RasterizerState.CullCounterClockwise;
        bool captureEntities = settings.CaptureEntities;
        bool captureBackground = settings.CaptureBackground;
        CaptureBiome biome = settings.Biome;
        Vector2 vector = screenPosition;
        int num2 = screenWidth;
        int num3 = screenHeight;
        float num4 = cloudAlpha;
        bool captureMech = settings.CaptureMech;
        screenWidth = area.Width << 4;
        screenHeight = area.Height << 4;
        screenPosition = new Vector2(area.X * 16, area.Y * 16);
        cloudAlpha = 0f;
        for (int i = 0; i <= 10; i++)
        {
            if (i != 1)
            {
                liquidAlpha[i] = ((i == biome.WaterStyle) ? 1f : 0f);
            }
        }
        int x = area.X;
        int y = area.Y;
        int num5 = area.X + screenWidth / 16;
        int num6 = area.Y + screenHeight / 16;
        float num7 = (biome.TileColor == CaptureBiome.TileColorStyle.Mushroom).ToInt();
        InfoToSetBackColor info = default(InfoToSetBackColor);
        info.isInGameMenuOrIsServer = gameMenu || netMode == 2;
        info.CorruptionBiomeInfluence = (biome.TileColor == CaptureBiome.TileColorStyle.Corrupt).ToInt();
        info.CrimsonBiomeInfluence = (biome.TileColor == CaptureBiome.TileColorStyle.Crimson).ToInt();
        info.JungleBiomeInfluence = (biome.TileColor == CaptureBiome.TileColorStyle.Jungle).ToInt();
        info.MushroomBiomeInfluence = num7;
        info.GraveyardInfluence = GraveyardVisualIntensity;
        info.BloodMoonActive = biome.WaterStyle == 9;
        info.LanternNightActive = LanternNight.LanternsUp;
        SetBackColor(info, out var sunColor, out var moonColor);
        ApplyColorOfTheSkiesToTiles();
        ColorOfSurfaceBackgroundsBase = (ColorOfSurfaceBackgroundsModified = ColorOfTheSkies);
        bool flag = mapEnabled;
        mapEnabled = false;
        Lighting.Initialize();
        renderCount = 99;
        for (int j = 0; j < 4; j++)
        {
            Lighting.LightTiles(x, num5, y, num6);
        }
        mapEnabled = flag;
        if (!((float)(settings.Area.X * 16) > vector.X - 16f) || !((float)(settings.Area.Y * 16) > vector.Y - 16f) || !((float)((settings.Area.X + settings.Area.Width) * 16) < vector.X + (float)num2 + 16f) || !((float)((settings.Area.Y + settings.Area.Height) * 16) < vector.Y + (float)num3 + 16f))
        {
            for (int k = 0; k < dust.Length; k++)
            {
                if (dust[k].active && dust[k].type == 76)
                {
                    dust[k].active = false;
                }
            }
        }
        Vector2 vector2 = (drawToScreen ? Vector2.Zero : new Vector2(offScreenRange, offScreenRange));
        int val = (int)((screenPosition.X - vector2.X) / 16f - 1f);
        int val2 = (int)((screenPosition.X + (float)screenWidth + vector2.X) / 16f) + 2;
        int val3 = (int)((screenPosition.Y - vector2.Y) / 16f - 1f);
        int val4 = (int)((screenPosition.Y + (float)screenHeight + vector2.Y) / 16f) + 5;
        vector2 -= screenPosition;
        val = Math.Max(val, 5) - 2;
        val3 = Math.Max(val3, 5);
        val2 = Math.Min(val2, maxTilesX - 5) + 2;
        val4 = Math.Min(val4, maxTilesY - 5) + 4;
        Microsoft.Xna.Framework.Rectangle drawArea = new Microsoft.Xna.Framework.Rectangle(val, val3, val2 - val, val4 - val3);
        LiquidRenderer.Instance.PrepareDraw(drawArea);
        WorldGen.SectionTileFrameWithCheck(x, y, num5, num6);
        SceneArea sceneArea = default(SceneArea);
        if (captureBackground)
        {
            Matrix transform = Transform;
            int num8 = screenHeight;
            int num9 = screenWidth;
            Vector2 vector3 = screenPosition;
            bool flag2 = mapFullscreen;
            mapFullscreen = false;
            float num10 = scAdj;
            Vector2 vector4 = new Vector2(num2, num3);
            Vector2 vector5 = new Vector2(settings.Area.Width * 16, settings.Area.Height * 16) / vector4;
            vector5.X = Math.Max(1f, vector5.X);
            vector5.Y = Math.Max(1f, vector5.Y);
            Vector2[] array4 = new Vector2[numClouds];
            for (int l = 0; l < numClouds; l++)
            {
                array4[l] = cloud[l].position;
                cloud[l].position *= vector5;
            }
            if ((float)(settings.Area.Height * 16) >= 2000f || (float)(settings.Area.Width * 16) >= 2000f)
            {
                scAdj = 0f;
                float num11 = 2048f;
                float num12 = MathHelper.Clamp((float)settings.Area.Height * 16f / num11, 1f, 3f);
                screenWidth = settings.Area.Width * 16;
                screenHeight = Math.Min(2048, settings.Area.Height * 16);
                screenPosition.X = settings.Area.X * 16;
                screenPosition.Y = settings.Area.Y * 16;
                screenPosition.Y += Math.Max(0f, Math.Min(settings.Area.Height, (float)worldSurface) * 16f - num11 * num12);
                transform *= Matrix.CreateScale(num12);
                transform.Translation += new Vector3((settings.Area.X - area.X) * 16, (settings.Area.Y - area.Y) * 16, 0f);
                transform.Translation += new Vector3(0f, Math.Max(0f, Math.Min(settings.Area.Height, (float)worldSurface) * 16f - num11 * num12) / num12, 0f);
            }
            else if ((float)(settings.Area.X * 16) > vector.X - 16f && (float)(settings.Area.Y * 16) > vector.Y - 16f && (float)((settings.Area.X + settings.Area.Width) * 16) < vector.X + (float)num2 + 16f && (float)((settings.Area.Y + settings.Area.Height) * 16) < vector.Y + (float)num3 + 16f)
            {
                screenPosition = vector;
                screenWidth = num2;
                screenHeight = num3;
                transform.Translation += new Vector3(vector.X - (float)area.X * 16f, vector.Y - (float)area.Y * 16f, 0f);
            }
            Vector2 areaPosition = new Vector2(area.X * 16, area.Y * 16);
            int areaWidth = area.Width * 16;
            int areaHeight = area.Height * 16;
            tileBatch.Begin();
            DrawSimpleSurfaceBackground(areaPosition, areaWidth, areaHeight);
            tileBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.AnisotropicClamp, DepthStencilState.Default, RasterizerState.CullNone, null, transform);
            int num13 = screenWidth;
            int num14 = screenHeight;
            Vector2 zero = Vector2.Zero;
            if (num13 < 800)
            {
                int num15 = 800 - num13;
                zero.X -= (float)num15 * 0.5f;
                num13 = 800;
            }
            if (num14 < 600)
            {
                int num16 = 600 - num14;
                zero.Y -= (float)num16 * 0.5f;
                num14 = 600;
            }
            SceneArea sceneArea2 = default(SceneArea);
            sceneArea2.bgTopY = 0;
            sceneArea2.totalWidth = num13;
            sceneArea2.totalHeight = num14;
            sceneArea2.SceneLocalScreenPositionOffset = zero;
            SceneArea sceneArea3 = sceneArea2;
            sceneArea = sceneArea3;
            if (shimmerAlpha != 1f)
            {
                DrawStarsInBackground(sceneArea3, artificial: false);
            }
            if ((double)(screenPosition.Y / 16f) < worldSurface + 2.0)
            {
                DrawSunAndMoon(sceneArea3, moonColor, sunColor, num7);
            }
            DrawSurfaceBG();
            spriteBatch.End();
            for (int m = 0; m < numClouds; m++)
            {
                cloud[m].position = array4[m];
            }
            scAdj = num10;
            mapFullscreen = flag2;
            screenWidth = num9;
            screenHeight = num8;
            screenPosition = vector3;
        }
        if (captureBackground)
        {
            spriteBatch.Begin();
            DrawUnderworldBackground(flat: true);
            spriteBatch.End();
        }
        if (captureEntities)
        {
            spriteBatch.Begin();
            CacheNPCDraws();
            CacheProjDraws();
            DrawCachedNPCs(DrawCacheNPCsMoonMoon, behindTiles: true);
            spriteBatch.End();
        }
        if (shimmerAlpha > 0f && captureBackground)
        {
            spriteBatch.Begin();
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, Vector2.Zero, null, Microsoft.Xna.Framework.Color.Black * shimmerAlpha, 0f, Vector2.Zero, new Vector2(Camera.UnscaledSize.X + (float)(offScreenRange * 2), Camera.UnscaledSize.Y + (float)(offScreenRange * 2)), SpriteEffects.None, 0f);
            spriteBatch.End();
        }
        tileBatch.Begin();
        spriteBatch.Begin();
        DrawBlack(force: true);
        tileBatch.End();
        spriteBatch.End();
        tileBatch.Begin();
        spriteBatch.Begin();
        if (biome == null)
        {
            DrawLiquid(bg: true, waterStyle);
        }
        else
        {
            DrawLiquid(bg: true, bloodMoon ? 9 : biome.WaterStyle);
        }
        tileBatch.End();
        spriteBatch.End();
        if (shimmerAlpha > 0f && captureBackground)
        {
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null);
            PlayerInput.SetZoom_Unscaled();
            DrawStarsInBackground(sceneArea, artificial: true);
            spriteBatch.End();
            PlayerInput.SetDesiredZoomContext(ZoomContext.World);
        }
        if (captureBackground)
        {
            tileBatch.Begin();
            spriteBatch.Begin();
            DrawBackground();
            tileBatch.End();
            spriteBatch.End();
        }
        tileBatch.Begin();
        spriteBatch.Begin();
        DrawWalls();
        tileBatch.End();
        spriteBatch.End();
        if (captureEntities)
        {
            spriteBatch.Begin();
            DrawWoF();
            spriteBatch.End();
        }
        if (drawBackGore && captureEntities)
        {
            spriteBatch.Begin();
            DrawGoreBehind();
            spriteBatch.End();
            drawBackGore = true;
        }
        if (captureEntities)
        {
            spriteBatch.Begin();
            MoonlordDeathDrama.DrawPieces(spriteBatch);
            MoonlordDeathDrama.DrawExplosions(spriteBatch);
            spriteBatch.End();
        }
        bool flag3 = false;
        bool intoRenderTargets = false;
        bool intoRenderTargets2 = false;
        TilesRenderer.SpecificHacksForCapture();
        TilesRenderer.PreDrawTiles(solidLayer: false, flag3, intoRenderTargets2);
        tileBatch.Begin();
        spriteBatch.Begin();
        DrawCachedNPCs(DrawCacheNPCsBehindNonSolidTiles, behindTiles: true);
        int waterStyleOverride = (bloodMoon ? 9 : biome.WaterStyle);
        if (biome == null)
        {
            DrawTiles(solidLayer: false, flag3, intoRenderTargets);
        }
        else
        {
            DrawTiles(solidLayer: false, flag3, intoRenderTargets, waterStyleOverride);
        }
        tileBatch.End();
        spriteBatch.End();
        DrawTileEntities(solidLayer: false, flag3, intoRenderTargets);
        if (captureEntities)
        {
            spriteBatch.Begin();
            tileBatch.Begin();
            waterfallManager.FindWaterfalls(forced: true);
            waterfallManager.Draw(spriteBatch);
            tileBatch.End();
            spriteBatch.End();
        }
        if (captureEntities)
        {
            DrawCachedProjs(DrawCacheProjsBehindNPCsAndTiles);
            spriteBatch.Begin();
            DrawNPCs(behindTiles: true);
            spriteBatch.End();
        }
        TilesRenderer.PreDrawTiles(solidLayer: true, flag3, intoRenderTargets2);
        tileBatch.Begin();
        spriteBatch.Begin();
        if (biome == null)
        {
            DrawTiles(solidLayer: true, flag3, intoRenderTargets);
        }
        else
        {
            DrawTiles(solidLayer: true, flag3, intoRenderTargets, waterStyleOverride);
        }
        tileBatch.End();
        spriteBatch.End();
        DrawTileEntities(solidLayer: true, flag3, intoRenderTargets);
        if (captureEntities)
        {
            DrawPlayers_BehindNPCs();
            DrawCachedProjs(DrawCacheProjsBehindNPCs);
            spriteBatch.Begin();
            DrawNPCs();
            spriteBatch.End();
            spriteBatch.Begin();
            DrawCachedNPCs(DrawCacheNPCProjectiles, behindTiles: false);
            spriteBatch.End();
            DrawSuperSpecialProjectiles(DrawCacheFirstFractals);
            DrawCachedProjs(DrawCacheProjsBehindProjectiles);
            DrawProjectiles();
            DrawPlayers_AfterProjectiles();
            DrawCachedProjs(DrawCacheProjsOverPlayers);
            spriteBatch.Begin();
            DrawCachedNPCs(DrawCacheNPCsOverPlayers, behindTiles: false);
            spriteBatch.End();
            spriteBatch.Begin();
            DrawItems();
            spriteBatch.End();
            spriteBatch.Begin();
            DrawRain();
            spriteBatch.End();
            spriteBatch.Begin();
            DrawGore();
            spriteBatch.End();
            DrawDust();
        }
        tileBatch.Begin();
        spriteBatch.Begin();
        if (biome == null)
        {
            DrawLiquid(bg: false, waterStyle);
        }
        else
        {
            DrawLiquid(bg: false, biome.WaterStyle);
        }
        if (captureMech)
        {
            DrawWires();
        }
        tileBatch.End();
        spriteBatch.End();
        DrawCachedProjs(DrawCacheProjsOverWiresUI);
        if (mapEnabled)
        {
            spriteBatch.Begin();
            for (int n = area.X; n < area.X + area.Width; n++)
            {
                for (int num17 = area.Y; num17 < area.Y + area.Height; num17++)
                {
                    if (!Map.IsRevealed(n, num17))
                    {
                        spriteBatch.Draw(TextureAssets.BlackTile.Value, new Vector2((float)n * 16f, (float)num17 * 16f) - screenPosition, Microsoft.Xna.Framework.Color.Black);
                    }
                }
            }
            spriteBatch.End();
        }
        renderCount = 99;
        screenWidth = num2;
        screenHeight = num3;
        screenPosition = vector;
        liquidAlpha = array3;
        offScreenRange = num;
        cloudAlpha = num4;
        bgAlphaFrontLayer = array;
        bgAlphaFarBackLayer = array2;
        SceneMetrics.HolyTileCount = holyTileCount;
        Lighting.Initialize();
        GameViewMatrix = gameViewMatrix;
    }
 
    protected void RenderTiles()
    {
        if (drawToScreen)
        {
            return;
        }
        RenderBlack();
        base.GraphicsDevice.SetRenderTarget(tileTarget);
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
        spriteBatch.Begin();
        tileBatch.Begin();
        try
        {
            TilesRenderer.PreDrawTiles(solidLayer: true, forRenderTargets: false, intoRenderTargets: true);
            DrawTiles(solidLayer: true, forRenderTargets: false, intoRenderTargets: true);
        }
        catch (Exception e)
        {
            if (!ignoreErrors)
            {
                throw;
            }
            TimeLogger.DrawException(e);
        }
        TimeLogger.DetailedDrawReset();
        tileBatch.End();
        spriteBatch.End();
        DrawTileEntities(solidLayer: true, overRenderTargets: false, intoRenderTargets: true);
        TimeLogger.DetailedDrawTime(28);
        base.GraphicsDevice.SetRenderTarget(null);
    }
 
    protected void RenderTiles2()
    {
        if (drawToScreen)
        {
            return;
        }
        base.GraphicsDevice.SetRenderTarget(tile2Target);
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
        spriteBatch.Begin();
        tileBatch.Begin();
        try
        {
            TilesRenderer.PreDrawTiles(solidLayer: false, forRenderTargets: false, intoRenderTargets: true);
            DrawTiles(solidLayer: false, forRenderTargets: false, intoRenderTargets: true);
        }
        catch (Exception e)
        {
            if (!ignoreErrors)
            {
                throw;
            }
            TimeLogger.DrawException(e);
        }
        TimeLogger.DetailedDrawReset();
        tileBatch.End();
        spriteBatch.End();
        DrawTileEntities(solidLayer: false, overRenderTargets: false, intoRenderTargets: true);
        TimeLogger.DetailedDrawTime(29);
        base.GraphicsDevice.SetRenderTarget(null);
    }
 
    protected void RenderWater()
    {
        if (!drawToScreen)
        {
            base.GraphicsDevice.SetRenderTarget(waterTarget);
            base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
            spriteBatch.Begin();
            try
            {
                DrawWaters();
            }
            catch
            {
            }
            TimeLogger.DetailedDrawReset();
            spriteBatch.End();
            TimeLogger.DetailedDrawTime(31);
            base.GraphicsDevice.SetRenderTarget(null);
        }
    }
 
    public static int CalculateWaterStyle(bool ignoreFountains = false)
    {
        if (SceneMetrics.ActiveFountainColor >= 0 && !ignoreFountains)
        {
            return SceneMetrics.ActiveFountainColor;
        }
        if (bloodMoon && !dayTime)
        {
            return 9;
        }
        switch (bgStyle)
        {
        case 1:
            return 2;
        case 5:
            if (SceneMetrics.EvilTileCount > SceneMetrics.HolyTileCount && SceneMetrics.EvilTileCount > SceneMetrics.BloodTileCount)
            {
                return 2;
            }
            if (SceneMetrics.HolyTileCount > SceneMetrics.BloodTileCount)
            {
                return 4;
            }
            return 10;
        case 3:
            return 3;
        case 8:
            return 10;
        case 6:
            return 4;
        case 7:
            return 5;
        case 2:
            if (remixWorld)
            {
                return 6;
            }
            if ((double)(player[myPlayer].position.Y / 16f) > worldSurface)
            {
                return 12;
            }
            return 6;
        case 4:
            return 13;
        default:
            if (remixWorld)
            {
                if ((double)(screenPosition.Y / 16f) > rockLayer)
                {
                    return 7;
                }
                if ((double)(screenPosition.Y / 16f) > worldSurface)
                {
                    return 8;
                }
            }
            else
            {
                if ((double)(screenPosition.Y / 16f) > rockLayer + 40.0)
                {
                    if (player[myPlayer].ZoneGlowshroom)
                    {
                        return 7;
                    }
                    return 8;
                }
                if ((double)(screenPosition.Y / 16f) > worldSurface)
                {
                    return 7;
                }
            }
            return 0;
        }
    }
 
    public static bool IsLiquidStyleWater(int liquidStyle)
    {
        if (liquidStyle != 1)
        {
            return liquidStyle != 11;
        }
        return false;
    }
 
    private void DrawWaters(bool isBackground = false)
    {
        drewLava = false;
        if (!isBackground)
        {
            waterStyle = CalculateWaterStyle();
            for (int i = 0; i < 15; i++)
            {
                if (IsLiquidStyleWater(waterStyle))
                {
                    if (waterStyle != i)
                    {
                        liquidAlpha[i] = Math.Max(liquidAlpha[i] - 0.2f, 0f);
                    }
                    else
                    {
                        liquidAlpha[i] = Math.Min(liquidAlpha[i] + 0.2f, 1f);
                    }
                }
            }
        }
        if (!drawToScreen && !isBackground)
        {
            Vector2 vector = (drawToScreen ? Vector2.Zero : new Vector2(offScreenRange, offScreenRange));
            int val = (int)((Camera.ScaledPosition.X - vector.X) / 16f - 1f);
            int val2 = (int)((Camera.ScaledPosition.X + Camera.ScaledSize.X + vector.X) / 16f) + 2;
            int val3 = (int)((Camera.ScaledPosition.Y - vector.Y) / 16f - 1f);
            int val4 = (int)((Camera.ScaledPosition.Y + Camera.ScaledSize.Y + vector.Y) / 16f) + 5;
            val = Math.Max(val, 5) - 2;
            val3 = Math.Max(val3, 5);
            val2 = Math.Min(val2, maxTilesX - 5) + 2;
            val4 = Math.Min(val4, maxTilesY - 5) + 4;
            Microsoft.Xna.Framework.Rectangle drawArea = new Microsoft.Xna.Framework.Rectangle(val, val3, val2 - val, val4 - val3);
            LiquidRenderer.Instance.PrepareDraw(drawArea);
        }
        bool flag = false;
        for (int j = 0; j < 15; j++)
        {
            if (IsLiquidStyleWater(j) && liquidAlpha[j] > 0f && j != waterStyle)
            {
                DrawLiquid(isBackground, j, isBackground ? 1f : liquidAlpha[j], drawSinglePassLiquids: false);
                flag = true;
            }
        }
        DrawLiquid(isBackground, waterStyle, flag ? liquidAlpha[waterStyle] : 1f);
    }
 
    protected void DrawLiquid(bool bg = false, int waterStyle = 0, float Alpha = 1f, bool drawSinglePassLiquids = true)
    {
        if (!Lighting.NotRetro)
        {
            oldDrawWater(bg, waterStyle, Alpha);
            return;
        }
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        Vector2 drawOffset = (drawToScreen ? Vector2.Zero : new Vector2(offScreenRange, offScreenRange)) - screenPosition;
        if (bg)
        {
            TilesRenderer.DrawLiquidBehindTiles(waterStyle);
        }
        LiquidRenderer.Instance.DrawNormalLiquids(spriteBatch, drawOffset, waterStyle, Alpha, bg);
        if (drawSinglePassLiquids)
        {
            LiquidRenderer.Instance.DrawShimmer(spriteBatch, drawOffset, bg);
        }
        if (!bg)
        {
            TimeLogger.DrawTime(4, stopwatch.Elapsed.TotalMilliseconds);
        }
    }
 
    public static void DrawTileInWater(Vector2 drawOffset, int x, int y)
    {
        if (Main.tile[x, y] != null && Main.tile[x, y].active() && Main.tile[x, y].type == 518)
        {
            instance.LoadTiles(Main.tile[x, y].type);
            Tile tile = Main.tile[x, y];
            int num = tile.liquid / 16;
            num -= 3;
            if (WorldGen.SolidTile(x, y - 1) && num > 8)
            {
                num = 8;
            }
            Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(tile.frameX, tile.frameY, 16, 16);
            spriteBatch.Draw(TextureAssets.Tile[tile.type].Value, new Vector2(x * 16, y * 16 - num) + drawOffset, value, Lighting.GetColor(x, y), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
        }
    }
 
    public void oldDrawWater(bool bg = false, int Style = 0, float Alpha = 1f)
    {
        float num = 0f;
        float num2 = 99999f;
        float num3 = 99999f;
        int num4 = -1;
        int num5 = -1;
        Vector2 vector = new Vector2(offScreenRange, offScreenRange);
        if (drawToScreen)
        {
            vector = Vector2.Zero;
        }
        _ = new Microsoft.Xna.Framework.Color[4];
        int num6 = (int)(255f * (1f - gfxQuality) + 40f * gfxQuality);
        _ = gfxQuality;
        _ = gfxQuality;
        int num7 = (int)((screenPosition.X - vector.X) / 16f - 1f);
        int num8 = (int)((screenPosition.X + (float)screenWidth + vector.X) / 16f) + 2;
        int num9 = (int)((screenPosition.Y - vector.Y) / 16f - 1f);
        int num10 = (int)((screenPosition.Y + (float)screenHeight + vector.Y) / 16f) + 5;
        if (num7 < 5)
        {
            num7 = 5;
        }
        if (num8 > maxTilesX - 5)
        {
            num8 = maxTilesX - 5;
        }
        if (num9 < 5)
        {
            num9 = 5;
        }
        if (num10 > maxTilesY - 5)
        {
            num10 = maxTilesY - 5;
        }
        for (int i = num9; i < num10 + 4; i++)
        {
            for (int j = num7 - 2; j < num8 + 2; j++)
            {
                if (tile[j, i] == null)
                {
                    tile[j, i] = new Tile();
                }
                if (tile[j, i].liquid <= 0 || (tile[j, i].nactive() && tileSolid[tile[j, i].type] && !tileSolidTop[tile[j, i].type]) || !(Lighting.Brightness(j, i) > 0f || bg))
                {
                    continue;
                }
                Microsoft.Xna.Framework.Color color = Lighting.GetColor(j, i);
                float num11 = 256 - tile[j, i].liquid;
                num11 /= 32f;
                bool flag = false;
                int num12 = 0;
                if (tile[j, i].lava())
                {
                    if (drewLava)
                    {
                        continue;
                    }
                    float num13 = Math.Abs((float)(j * 16 + 8) - (screenPosition.X + (float)(screenWidth / 2)));
                    float num14 = Math.Abs((float)(i * 16 + 8) - (screenPosition.Y + (float)(screenHeight / 2)));
                    if (num13 < (float)(screenWidth * 2) && num14 < (float)(screenHeight * 2))
                    {
                        float num15 = (float)Math.Sqrt(num13 * num13 + num14 * num14);
                        float num16 = 1f - num15 / ((float)screenWidth * 0.75f);
                        if (num16 > 0f)
                        {
                            num += num16;
                        }
                    }
                    if (num13 < num2)
                    {
                        num2 = num13;
                        num4 = j * 16 + 8;
                    }
                    if (num14 < num3)
                    {
                        num3 = num13;
                        num5 = i * 16 + 8;
                    }
                    num12 = 1;
                }
                else if (tile[j, i].honey())
                {
                    num12 = 11;
                }
                else if (tile[j, i].shimmer())
                {
                    num12 = 14;
                    flag = true;
                }
                if (num12 == 0)
                {
                    num12 = Style;
                }
                if ((num12 == 1 || num12 == 11) && drewLava)
                {
                    continue;
                }
                float num17 = 0.5f;
                if (bg)
                {
                    num17 = 1f;
                }
                if (num12 != 1 && num12 != 11)
                {
                    num17 *= Alpha;
                }
                DrawTileInWater(-screenPosition + vector, j, i);
                Vector2 vector2 = new Vector2(j * 16, i * 16 + (int)num11 * 2);
                Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16 - (int)num11 * 2);
                bool flag2 = true;
                if (tile[j, i + 1].liquid < 245 && (!tile[j, i + 1].nactive() || !tileSolid[tile[j, i + 1].type] || tileSolidTop[tile[j, i + 1].type]))
                {
                    float num18 = 256 - tile[j, i + 1].liquid;
                    num18 /= 32f;
                    num17 = 0.5f * (8f - num11) / 4f;
                    if ((double)num17 > 0.55)
                    {
                        num17 = 0.55f;
                    }
                    if ((double)num17 < 0.35)
                    {
                        num17 = 0.35f;
                    }
                    float num19 = num11 / 2f;
                    if (tile[j, i + 1].liquid < 200)
                    {
                        if (bg)
                        {
                            continue;
                        }
                        if (tile[j, i - 1].liquid > 0 && tile[j, i - 1].liquid > 0)
                        {
                            value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 16);
                            num17 = 0.5f;
                        }
                        else if (tile[j, i - 1].liquid > 0)
                        {
                            vector2 = new Vector2(j * 16, i * 16 + 4);
                            value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 12);
                            num17 = 0.5f;
                        }
                        else if (tile[j, i + 1].liquid > 0)
                        {
                            vector2 = new Vector2(j * 16, i * 16 + (int)num11 * 2 + (int)num18 * 2);
                            value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 16 - (int)num11 * 2);
                        }
                        else
                        {
                            vector2 = new Vector2(j * 16 + (int)num19, i * 16 + (int)num19 * 2 + (int)num18 * 2);
                            value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16 - (int)num19 * 2, 16 - (int)num19 * 2);
                        }
                    }
                    else
                    {
                        num17 = 0.5f;
                        value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 16 - (int)num11 * 2 + (int)num18 * 2);
                    }
                }
                else if (tile[j, i - 1].liquid > 32)
                {
                    value = new Microsoft.Xna.Framework.Rectangle(0, 4, value.Width, value.Height);
                }
                else if (num11 < 1f && tile[j, i - 1].nactive() && tileSolid[tile[j, i - 1].type] && !tileSolidTop[tile[j, i - 1].type])
                {
                    vector2 = new Vector2(j * 16, i * 16);
                    value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 16);
                }
                else
                {
                    for (int k = i + 1; k < i + 6 && (!tile[j, k].nactive() || !tileSolid[tile[j, k].type] || tileSolidTop[tile[j, k].type]); k++)
                    {
                        if (tile[j, k].liquid < 200)
                        {
                            flag2 = false;
                            break;
                        }
                    }
                    if (!flag2)
                    {
                        num17 = 0.5f;
                        value = new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 16);
                    }
                    else if (tile[j, i - 1].liquid > 0)
                    {
                        value = new Microsoft.Xna.Framework.Rectangle(0, 2, value.Width, value.Height);
                    }
                }
                if ((color.R > 20 || color.B > 20 || color.G > 20) && value.Y < 4)
                {
                    int num20 = color.R;
                    if (color.G > num20)
                    {
                        num20 = color.G;
                    }
                    if (color.B > num20)
                    {
                        num20 = color.B;
                    }
                    num20 /= 30;
                    if (rand.Next(20000) < num20)
                    {
                        Microsoft.Xna.Framework.Color newColor = new Microsoft.Xna.Framework.Color(255, 255, 255);
                        if (tile[j, i].honey())
                        {
                            newColor = new Microsoft.Xna.Framework.Color(255, 255, 50);
                        }
                        int num21 = Dust.NewDust(new Vector2(j * 16, vector2.Y - 2f), 16, 8, 43, 0f, 0f, 254, newColor, 0.75f);
                        dust[num21].velocity *= 0f;
                    }
                }
                if (tile[j, i].honey())
                {
                    num17 *= 1.6f;
                    if (num17 > 1f)
                    {
                        num17 = 1f;
                    }
                }
                if (tile[j, i].lava())
                {
                    num17 *= 1.8f;
                    if (num17 > 1f)
                    {
                        num17 = 1f;
                    }
                    if (base.IsActive && !gamePaused && Dust.lavaBubbles < 200)
                    {
                        if (tile[j, i].liquid > 200 && rand.Next(700) == 0)
                        {
                            Dust.NewDust(new Vector2(j * 16, i * 16), 16, 16, 35);
                        }
                        if (value.Y == 0 && rand.Next(350) == 0)
                        {
                            int num22 = Dust.NewDust(new Vector2(j * 16, (float)(i * 16) + num11 * 2f - 8f), 16, 8, 35, 0f, 0f, 50, default(Microsoft.Xna.Framework.Color), 1.5f);
                            dust[num22].velocity *= 0.8f;
                            dust[num22].velocity.X *= 2f;
                            dust[num22].velocity.Y -= (float)rand.Next(1, 7) * 0.1f;
                            if (rand.Next(10) == 0)
                            {
                                dust[num22].velocity.Y *= rand.Next(2, 5);
                            }
                            dust[num22].noGravity = true;
                        }
                    }
                }
                float num23 = (float)(int)color.R * num17;
                float num24 = (float)(int)color.G * num17;
                float num25 = (float)(int)color.B * num17;
                float num26 = (float)(int)color.A * num17;
                color = new Microsoft.Xna.Framework.Color((byte)num23, (byte)num24, (byte)num25, (byte)num26);
                if (flag)
                {
                    color = new Microsoft.Xna.Framework.Color(color.ToVector4() * LiquidRenderer.GetShimmerBaseColor(j, i));
                }
                if (Lighting.NotRetro && !bg)
                {
                    Microsoft.Xna.Framework.Color color2 = color;
                    if (num12 != 1 && ((double)(int)color2.R > (double)num6 * 0.6 || (double)(int)color2.G > (double)num6 * 0.65 || (double)(int)color2.B > (double)num6 * 0.7))
                    {
                        for (int l = 0; l < 4; l++)
                        {
                            int num27 = 0;
                            int num28 = 0;
                            int width = 8;
                            int height = 8;
                            Microsoft.Xna.Framework.Color color3 = color2;
                            Microsoft.Xna.Framework.Color color4 = Lighting.GetColor(j, i);
                            if (l == 0)
                            {
                                color4 = Lighting.GetColor(j - 1, i - 1);
                                if (value.Height < 8)
                                {
                                    height = value.Height;
                                }
                            }
                            if (l == 1)
                            {
                                color4 = Lighting.GetColor(j + 1, i - 1);
                                num27 = 8;
                                if (value.Height < 8)
                                {
                                    height = value.Height;
                                }
                            }
                            if (l == 2)
                            {
                                color4 = Lighting.GetColor(j - 1, i + 1);
                                num28 = 8;
                                height = 8 - (16 - value.Height);
                            }
                            if (l == 3)
                            {
                                color4 = Lighting.GetColor(j + 1, i + 1);
                                num27 = 8;
                                num28 = 8;
                                height = 8 - (16 - value.Height);
                            }
                            num23 = (float)(int)color4.R * num17;
                            num24 = (float)(int)color4.G * num17;
                            num25 = (float)(int)color4.B * num17;
                            num26 = (float)(int)color4.A * num17;
                            color4 = new Microsoft.Xna.Framework.Color((byte)num23, (byte)num24, (byte)num25, (byte)num26);
                            color3.R = (byte)((color2.R * 3 + color4.R * 2) / 5);
                            color3.G = (byte)((color2.G * 3 + color4.G * 2) / 5);
                            color3.B = (byte)((color2.B * 3 + color4.B * 2) / 5);
                            color3.A = (byte)((color2.A * 3 + color4.A * 2) / 5);
                            if (flag)
                            {
                                color3 = new Microsoft.Xna.Framework.Color(color3.ToVector4() * LiquidRenderer.GetShimmerBaseColor(j, i));
                            }
                            spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + new Vector2(num27, num28) + vector, new Microsoft.Xna.Framework.Rectangle(value.X + num27, value.Y + num28, width, height), color3, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                            if (flag)
                            {
                                spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + new Vector2(num27, num28) + vector, new Microsoft.Xna.Framework.Rectangle(value.X + num27, value.Y + num28 + 36, width, height), LiquidRenderer.GetShimmerGlitterColor(flag2, j, i), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                            }
                        }
                    }
                    else
                    {
                        spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, value, color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        if (flag)
                        {
                            value.Y += 36;
                            spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, value, LiquidRenderer.GetShimmerGlitterColor(flag2, j, i), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                        }
                    }
                }
                else
                {
                    if (value.Y < 4)
                    {
                        value.X += (int)(wFrame * 18f);
                    }
                    spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, value, color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                    if (flag)
                    {
                        value.Y += 36;
                        spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, value, LiquidRenderer.GetShimmerGlitterColor(flag2, j, i), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                    }
                }
                if (!tile[j, i + 1].halfBrick())
                {
                    continue;
                }
                color = Lighting.GetColor(j, i + 1);
                num23 = (float)(int)color.R * num17;
                num24 = (float)(int)color.G * num17;
                num25 = (float)(int)color.B * num17;
                num26 = (float)(int)color.A * num17;
                color = new Microsoft.Xna.Framework.Color((byte)num23, (byte)num24, (byte)num25, (byte)num26);
                if (flag)
                {
                    color = new Microsoft.Xna.Framework.Color(color.ToVector4() * LiquidRenderer.GetShimmerBaseColor(j, i));
                }
                vector2 = new Vector2(j * 16, i * 16 + 16);
                spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, new Microsoft.Xna.Framework.Rectangle(0, 4, 16, 8), color, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                if (flag)
                {
                    spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, new Microsoft.Xna.Framework.Rectangle(0, 40, 16, 8), LiquidRenderer.GetShimmerGlitterColor(flag2, j, i), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                }
                float num29 = 6f;
                float num30 = 0.75f;
                if (num12 == 1 || num12 == 11)
                {
                    num29 = 4f;
                    num30 = 0.5f;
                }
                for (int m = 0; (float)m < num29; m++)
                {
                    int num31 = i + 2 + m;
                    if (WorldGen.SolidTile(j, num31))
                    {
                        break;
                    }
                    float num32 = 1f - (float)m / num29;
                    num32 *= num30;
                    vector2 = new Vector2(j * 16, num31 * 16 - 2);
                    spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, new Microsoft.Xna.Framework.Rectangle(0, 18, 16, 16), color * num32, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                    if (flag)
                    {
                        spriteBatch.Draw(TextureAssets.Liquid[num12].Value, vector2 - screenPosition + vector, new Microsoft.Xna.Framework.Rectangle(0, 54, 16, 16), LiquidRenderer.GetShimmerGlitterColor(flag2, j, i) * num32, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                    }
                }
            }
        }
        if (!drewLava)
        {
            ambientLavaX = num4;
            ambientLavaY = num5;
            ambientLavaStrength = num;
        }
        drewLava = true;
    }
 
    protected bool FullTile(int x, int y)
    {
        if (Main.tile[x - 1, y] == null || Main.tile[x - 1, y].blockType() != 0 || Main.tile[x + 1, y] == null || Main.tile[x + 1, y].blockType() != 0)
        {
            return false;
        }
        Tile tile = Main.tile[x, y];
        if (tile == null)
        {
            return false;
        }
        if (tile.active())
        {
            if (tile.type < TileID.Sets.DrawsWalls.Length && TileID.Sets.DrawsWalls[tile.type])
            {
                return false;
            }
            if (tileSolid[tile.type] && !tileSolidTop[tile.type])
            {
                int frameX = tile.frameX;
                int frameY = tile.frameY;
                if (tileLargeFrames[tile.type] > 0)
                {
                    if (frameY == 18 || frameY == 108)
                    {
                        if (frameX >= 18 && frameX <= 54)
                        {
                            return true;
                        }
                        if (frameX >= 108 && frameX <= 144)
                        {
                            return true;
                        }
                    }
                }
                else if (frameY == 18)
                {
                    if (frameX >= 18 && frameX <= 54)
                    {
                        return true;
                    }
                    if (frameX >= 108 && frameX <= 144)
                    {
                        return true;
                    }
                }
                else if (frameY >= 90 && frameY <= 196)
                {
                    if (frameX <= 70)
                    {
                        return true;
                    }
                    if (frameX >= 144 && frameX <= 232)
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
 
    protected void DrawBlack(bool force = false)
    {
        if (shimmerAlpha == 1f)
        {
            return;
        }
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        Vector2 vector = (drawToScreen ? Vector2.Zero : new Vector2(offScreenRange, offScreenRange));
        int num = (tileColor.R + tileColor.G + tileColor.B) / 3;
        float num2 = (float)((double)num * 0.4) / 255f;
        if (Lighting.Mode == LightMode.Retro)
        {
            num2 = (float)(tileColor.R - 55) / 255f;
            if (num2 < 0f)
            {
                num2 = 0f;
            }
        }
        else if (Lighting.Mode == LightMode.Trippy)
        {
            num2 = (float)(num - 55) / 255f;
            if (num2 < 0f)
            {
                num2 = 0f;
            }
        }
        Microsoft.Xna.Framework.Point screenOverdrawOffset = GetScreenOverdrawOffset();
        Microsoft.Xna.Framework.Point point = new Microsoft.Xna.Framework.Point(-offScreenRange / 16 + screenOverdrawOffset.X, -offScreenRange / 16 + screenOverdrawOffset.Y);
        int num3 = (int)((screenPosition.X - vector.X) / 16f - 1f) + point.X;
        int num4 = (int)((screenPosition.X + (float)screenWidth + vector.X) / 16f) + 2 - point.X;
        int num5 = (int)((screenPosition.Y - vector.Y) / 16f - 1f) + point.Y;
        int num6 = (int)((screenPosition.Y + (float)screenHeight + vector.Y) / 16f) + 5 - point.Y;
        if (num3 < 0)
        {
            num3 = point.X;
        }
        if (num4 > maxTilesX)
        {
            num4 = maxTilesX - point.X;
        }
        if (num5 < 0)
        {
            num5 = point.Y;
        }
        if (num6 > maxTilesY)
        {
            num6 = maxTilesY - point.Y;
        }
        if (!force)
        {
            if (num5 < maxTilesY / 2)
            {
                num6 = Math.Min(num6, (int)worldSurface + 1);
                num5 = Math.Min(num5, (int)worldSurface + 1);
            }
            else
            {
                num6 = Math.Max(num6, UnderworldLayer);
                num5 = Math.Max(num5, UnderworldLayer);
            }
        }
        bool flag = ShouldShowInvisibleWalls();
        for (int i = num5; i < num6; i++)
        {
            bool flag2 = i >= UnderworldLayer;
            if (flag2)
            {
                num2 = 0.2f;
            }
            for (int j = num3; j < num4; j++)
            {
                int num7 = j;
                for (; j < num4; j++)
                {
                    if (!WorldGen.InWorld(j, i))
                    {
                        return;
                    }
                    if (Main.tile[j, i] == null)
                    {
                        Main.tile[j, i] = new Tile();
                    }
                    Tile tile = Main.tile[j, i];
                    float num8 = Lighting.Brightness(j, i);
                    num8 = (float)Math.Floor(num8 * 255f) / 255f;
                    byte b = tile.liquid;
                    bool num9 = num8 <= num2 && ((!flag2 && b < 250) || WorldGen.SolidTile(tile) || (b >= 200 && num8 == 0f));
                    bool flag3 = tile.active() && tileBlockLight[tile.type] && (!tile.invisibleBlock() || flag);
                    bool flag4 = !WallID.Sets.Transparent[tile.wall] && (!tile.invisibleWall() || flag);
                    if (!num9 || (!flag4 && !flag3) || (!drawToScreen && LiquidRenderer.Instance.HasFullWater(j, i) && tile.wall == 0 && !tile.halfBrick() && !((double)i <= worldSurface)))
                    {
                        break;
                    }
                }
                if (j - num7 > 0)
                {
                    spriteBatch.Draw(TextureAssets.BlackTile.Value, new Vector2(num7 << 4, i << 4) - screenPosition + vector, new Microsoft.Xna.Framework.Rectangle(0, 0, j - num7 << 4, 16), Microsoft.Xna.Framework.Color.Black);
                }
            }
        }
        TimeLogger.DrawTime(5, stopwatch.Elapsed.TotalMilliseconds);
    }
 
    public static bool ShouldShowInvisibleWalls()
    {
        if (!SceneMetrics.EchoMonolith)
        {
            return LocalPlayer.CanSeeInvisibleBlocks;
        }
        return true;
    }
 
    protected void RenderBlack()
    {
        if (!drawToScreen)
        {
            base.GraphicsDevice.SetRenderTarget(blackTarget);
            base.GraphicsDevice.DepthStencilState = new DepthStencilState
            {
                DepthBufferEnable = true
            };
            base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
            spriteBatch.Begin();
            DrawBlack();
            TimeLogger.DetailedDrawReset();
            spriteBatch.End();
            TimeLogger.DetailedDrawTime(30);
            base.GraphicsDevice.SetRenderTarget(null);
        }
    }
 
    protected void DrawWalls()
    {
        WallsRenderer.DrawWalls();
    }
 
    protected void RenderWalls()
    {
        if (drawToScreen)
        {
            return;
        }
        base.GraphicsDevice.SetRenderTarget(wallTarget);
        base.GraphicsDevice.DepthStencilState = new DepthStencilState
        {
            DepthBufferEnable = true
        };
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Transparent);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend);
        tileBatch.Begin();
        if (ignoreErrors)
        {
            try
            {
                DrawWalls();
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
            }
        }
        else
        {
            DrawWalls();
        }
        TimeLogger.DetailedDrawReset();
        tileBatch.End();
        spriteBatch.End();
        TimeLogger.DetailedDrawTime(32);
        base.GraphicsDevice.SetRenderTarget(null);
    }
 
    protected void ReleaseTargets()
    {
        try
        {
            if (!dedServ)
            {
                offScreenRange = 0;
                targetSet = false;
                if (waterTarget != null)
                {
                    waterTarget.Dispose();
                }
                if (backWaterTarget != null)
                {
                    backWaterTarget.Dispose();
                }
                if (blackTarget != null)
                {
                    blackTarget.Dispose();
                }
                if (tileTarget != null)
                {
                    tileTarget.Dispose();
                }
                if (tile2Target != null)
                {
                    tile2Target.Dispose();
                }
                if (wallTarget != null)
                {
                    wallTarget.Dispose();
                }
                if (screenTarget != null)
                {
                    screenTarget.Dispose();
                }
                if (screenTargetSwap != null)
                {
                    screenTargetSwap.Dispose();
                }
                if (backgroundTarget != null)
                {
                    backgroundTarget.Dispose();
                }
                if (Main.OnRenderTargetsReleased != null)
                {
                    Main.OnRenderTargetsReleased();
                }
            }
        }
        catch
        {
        }
    }
 
    protected bool checkMap(int i, int j)
    {
        if (mapTarget[i, j] == null || mapTarget[i, j].IsDisposed)
        {
            initMap[i, j] = false;
        }
        if (!initMap[i, j])
        {
            try
            {
                int width = textureMaxWidth;
                int height = textureMaxHeight;
                if (i == mapTargetX - 1)
                {
                    width = 400;
                }
                if (j == mapTargetY - 1)
                {
                    height = 600;
                }
                mapTarget[i, j] = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None, 0, RenderTargetUsage.PreserveContents);
            }
            catch
            {
                mapEnabled = false;
                for (int k = 0; k < mapTargetX; k++)
                {
                    for (int l = 0; l < mapTargetY; l++)
                    {
                        try
                        {
                            initMap[k, l] = false;
                            mapTarget[k, l].Dispose();
                        }
                        catch
                        {
                        }
                    }
                }
                return false;
            }
            initMap[i, j] = true;
        }
        return true;
    }
 
    protected void InitMap()
    {
        int num = mapTargetX;
        int num2 = mapTargetY;
        if (!mapEnabled)
        {
            return;
        }
        try
        {
            for (int i = 0; i < num; i++)
            {
                for (int j = 0; j < num2; j++)
                {
                    mapTarget[i, j] = new RenderTarget2D(base.GraphicsDevice, textureMaxWidth, textureMaxHeight, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None, 0, RenderTargetUsage.PreserveContents);
                }
            }
            mapInit = true;
        }
        catch
        {
            mapEnabled = false;
            for (int k = 0; k < num; k++)
            {
                for (int l = 0; l < num2; l++)
                {
                    try
                    {
                        if (mapTarget[k, l] != null)
                        {
                            mapTarget[k, l].Dispose();
                        }
                    }
                    catch
                    {
                    }
                }
            }
        }
    }
 
    protected void InitTargets()
    {
        if (!PreventUpdatingTargets)
        {
            UpdateDisplaySettings();
        }
        InitTargets(base.GraphicsDevice.PresentationParameters.BackBufferWidth, base.GraphicsDevice.PresentationParameters.BackBufferHeight);
    }
 
    protected void EnsureRenderTargetContent()
    {
        if (waterTarget == null || waterTarget.IsContentLost || backWaterTarget == null || backWaterTarget.IsContentLost || blackTarget == null || blackTarget.IsContentLost || tileTarget == null || tileTarget.IsContentLost || tile2Target == null || tile2Target.IsContentLost || wallTarget == null || wallTarget.IsContentLost || backgroundTarget == null || backgroundTarget.IsContentLost || screenTarget == null || screenTarget.IsContentLost || screenTargetSwap == null || screenTargetSwap.IsContentLost)
        {
            InitTargets();
        }
    }
 
    protected void InitTargets(int width, int height)
    {
        ReleaseTargets();
        offScreenRange = 192;
        if (width + offScreenRange * 2 > _renderTargetMaxSize)
        {
            offScreenRange = (_renderTargetMaxSize - width) / 2;
        }
        width += offScreenRange * 2;
        height += offScreenRange * 2;
        try
        {
            if (!dedServ)
            {
                targetSet = true;
                waterTarget = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                backWaterTarget = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                blackTarget = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                tileTarget = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                tile2Target = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                wallTarget = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                backgroundTarget = new RenderTarget2D(base.GraphicsDevice, width, height, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                screenTarget = new RenderTarget2D(base.GraphicsDevice, base.GraphicsDevice.PresentationParameters.BackBufferWidth, base.GraphicsDevice.PresentationParameters.BackBufferHeight, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                screenTargetSwap = new RenderTarget2D(base.GraphicsDevice, base.GraphicsDevice.PresentationParameters.BackBufferWidth, base.GraphicsDevice.PresentationParameters.BackBufferHeight, mipMap: false, base.GraphicsDevice.PresentationParameters.BackBufferFormat, DepthFormat.None);
                if (Main.OnRenderTargetsInitialized != null)
                {
                    Main.OnRenderTargetsInitialized(base.GraphicsDevice.PresentationParameters.BackBufferWidth, base.GraphicsDevice.PresentationParameters.BackBufferHeight);
                }
            }
        }
        catch
        {
            Lighting.Mode = LightMode.Retro;
            mapEnabled = false;
            SaveSettings();
            try
            {
                ReleaseTargets();
            }
            catch
            {
            }
        }
    }
 
    protected void DrawWires()
    {
        Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(0, 0, 16, 16);
        Vector2 zero = Vector2.Zero;
        DrawWiresSpecialTiles.Clear();
        bool flag = !WiresUI.Settings.HideWires;
        float num = 1f;
        if (WiresUI.Settings.HideWires)
        {
            num = 0.5f;
        }
        int num2 = 1;
        int num3 = 1;
        int num4 = 1;
        int num5 = 1;
        int num6 = 1;
        if (player[myPlayer].InfoAccMechShowWires)
        {
            int[] builderAccStatus = player[myPlayer].builderAccStatus;
            num2 = builderAccStatus[4];
            num3 = builderAccStatus[5];
            num4 = builderAccStatus[6];
            num5 = builderAccStatus[7];
            num6 = builderAccStatus[9];
        }
        _ = gfxQuality;
        _ = gfxQuality;
        Vector2 zero2 = Vector2.Zero;
        if (drawToScreen)
        {
            zero2 = Vector2.Zero;
        }
        int num7 = (int)((screenPosition.X - zero2.X) / 16f - 1f);
        int num8 = (int)((screenPosition.X + (float)screenWidth + zero2.X) / 16f) + 2;
        int num9 = (int)((screenPosition.Y - zero2.Y) / 16f - 1f);
        int num10 = (int)((screenPosition.Y + (float)screenHeight + zero2.Y) / 16f) + 5;
        if (num7 < 0)
        {
            num7 = 0;
        }
        if (num8 > maxTilesX)
        {
            num8 = maxTilesX;
        }
        if (num9 < 0)
        {
            num9 = 0;
        }
        if (num10 > maxTilesY)
        {
            num10 = maxTilesY;
        }
        Microsoft.Xna.Framework.Point screenOverdrawOffset = GetScreenOverdrawOffset();
        for (int i = num9 + screenOverdrawOffset.Y; i < num10 - screenOverdrawOffset.Y; i++)
        {
            for (int j = num7 + screenOverdrawOffset.X; j < num8 - screenOverdrawOffset.X; j++)
            {
                bool flag2 = false;
                bool flag3 = false;
                bool flag4 = false;
                bool flag5 = false;
                bool flag6 = false;
                bool flag7 = false;
                bool flag8 = false;
                bool flag9 = false;
                bool flag10 = false;
                float num11 = 0f;
                Tile tile = Main.tile[j, i];
                if (flag && player[myPlayer].CanDoWireStuffHere(j, i))
                {
                    int num12 = 0;
                    if (tile.active())
                    {
                        if (tile.type == 424)
                        {
                            switch (tile.frameX / 18)
                            {
                            case 0:
                                num12 += 72;
                                break;
                            case 1:
                                num12 += 144;
                                break;
                            case 2:
                                num12 += 216;
                                break;
                            }
                        }
                        else if (tile.type == 445)
                        {
                            num12 += 72;
                        }
                    }
                    if (tile.wire())
                    {
                        num11 += 1f;
                        int num13 = 0;
                        if (Main.tile[j, i - 1].wire())
                        {
                            num13 += 18;
                            flag4 = true;
                        }
                        if (Main.tile[j + 1, i].wire())
                        {
                            num13 += 36;
                            flag3 = true;
                        }
                        if (Main.tile[j, i + 1].wire())
                        {
                            num13 += 72;
                            flag5 = true;
                        }
                        if (Main.tile[j - 1, i].wire())
                        {
                            num13 += 144;
                            flag2 = true;
                        }
                        value.Y = num12;
                        value.X = num13;
                        Microsoft.Xna.Framework.Color color = Lighting.GetColor(j, i);
                        switch (num2)
                        {
                        case 0:
                            color = Microsoft.Xna.Framework.Color.White;
                            break;
                        case 2:
                            color *= 0.5f;
                            break;
                        case 3:
                            color = Microsoft.Xna.Framework.Color.Transparent;
                            break;
                        }
                        if (color == Microsoft.Xna.Framework.Color.Transparent)
                        {
                            num11 -= 1f;
                        }
                        else
                        {
                            spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, value, color, 0f, zero, 1f, SpriteEffects.None, 0f);
                        }
                    }
                    if (tile.wire2())
                    {
                        flag6 = (flag7 = (flag8 = (flag9 = (flag10 = false))));
                        num11 += 1f;
                        int num14 = 0;
                        if (Main.tile[j, i - 1].wire2())
                        {
                            num14 += 18;
                            flag8 = true;
                            if (flag4)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j + 1, i].wire2())
                        {
                            num14 += 36;
                            flag7 = true;
                            if (flag3)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j, i + 1].wire2())
                        {
                            num14 += 72;
                            flag9 = true;
                            if (flag5)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j - 1, i].wire2())
                        {
                            num14 += 144;
                            flag6 = true;
                            if (flag2)
                            {
                                flag10 = true;
                            }
                        }
                        if (num11 > 1f)
                        {
                            flag10 = true;
                        }
                        value.Y = num12 + 18;
                        value.X = num14;
                        Microsoft.Xna.Framework.Color color2 = Lighting.GetColor(j, i);
                        switch (num3)
                        {
                        case 0:
                            color2 = Microsoft.Xna.Framework.Color.White;
                            break;
                        case 2:
                            color2 *= 0.5f;
                            break;
                        case 3:
                            color2 = Microsoft.Xna.Framework.Color.Transparent;
                            break;
                        }
                        if (color2 == Microsoft.Xna.Framework.Color.Transparent)
                        {
                            num11 -= 1f;
                        }
                        else
                        {
                            spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, value, color2 * (1f / num11), 0f, zero, 1f, SpriteEffects.None, 0f);
                            if (flag8)
                            {
                                if (flag10 && !flag4)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(18, value.Y, 16, 6), color2, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag4 = true;
                            }
                            if (flag9)
                            {
                                if (flag10 && !flag5)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2 + new Vector2(0f, 10f), new Microsoft.Xna.Framework.Rectangle(72, value.Y + 10, 16, 6), color2, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag5 = true;
                            }
                            if (flag7)
                            {
                                if (flag10 && !flag3)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2 + new Vector2(10f, 0f), new Microsoft.Xna.Framework.Rectangle(46, value.Y, 6, 16), color2, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag3 = true;
                            }
                            if (flag6)
                            {
                                if (flag10 && !flag2)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(144, value.Y, 6, 16), color2, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag2 = true;
                            }
                        }
                    }
                    if (tile.wire3())
                    {
                        flag6 = (flag7 = (flag8 = (flag9 = (flag10 = false))));
                        num11 += 1f;
                        int num15 = 0;
                        if (Main.tile[j, i - 1].wire3())
                        {
                            num15 += 18;
                            flag8 = true;
                            if (flag4)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j + 1, i].wire3())
                        {
                            num15 += 36;
                            flag7 = true;
                            if (flag3)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j, i + 1].wire3())
                        {
                            num15 += 72;
                            flag9 = true;
                            if (flag5)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j - 1, i].wire3())
                        {
                            num15 += 144;
                            flag6 = true;
                            if (flag2)
                            {
                                flag10 = true;
                            }
                        }
                        if (num11 > 1f)
                        {
                            flag10 = true;
                        }
                        value.Y = num12 + 36;
                        value.X = num15;
                        Microsoft.Xna.Framework.Color color3 = Lighting.GetColor(j, i);
                        switch (num4)
                        {
                        case 0:
                            color3 = Microsoft.Xna.Framework.Color.White;
                            break;
                        case 2:
                            color3 *= 0.5f;
                            break;
                        case 3:
                            color3 = Microsoft.Xna.Framework.Color.Transparent;
                            break;
                        }
                        if (color3 == Microsoft.Xna.Framework.Color.Transparent)
                        {
                            num11 -= 1f;
                        }
                        else
                        {
                            spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, value, color3 * (1f / num11), 0f, zero, 1f, SpriteEffects.None, 0f);
                            if (flag8)
                            {
                                if (flag10 && !flag4)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(18, value.Y, 16, 6), color3, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag4 = true;
                            }
                            if (flag9)
                            {
                                if (flag10 && !flag5)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2 + new Vector2(0f, 10f), new Microsoft.Xna.Framework.Rectangle(72, value.Y + 10, 16, 6), color3, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag5 = true;
                            }
                            if (flag7)
                            {
                                if (flag10 && !flag3)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2 + new Vector2(10f, 0f), new Microsoft.Xna.Framework.Rectangle(46, value.Y, 6, 16), color3, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag3 = true;
                            }
                            if (flag6)
                            {
                                if (flag10 && !flag2)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(144, value.Y, 6, 16), color3, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag2 = true;
                            }
                        }
                    }
                    if (tile.wire4())
                    {
                        flag6 = (flag7 = (flag8 = (flag9 = (flag10 = false))));
                        num11 += 1f;
                        int num16 = 0;
                        if (Main.tile[j, i - 1].wire4())
                        {
                            num16 += 18;
                            flag8 = true;
                            if (flag4)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j + 1, i].wire4())
                        {
                            num16 += 36;
                            flag7 = true;
                            if (flag3)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j, i + 1].wire4())
                        {
                            num16 += 72;
                            flag9 = true;
                            if (flag5)
                            {
                                flag10 = true;
                            }
                        }
                        if (Main.tile[j - 1, i].wire4())
                        {
                            num16 += 144;
                            flag6 = true;
                            if (flag2)
                            {
                                flag10 = true;
                            }
                        }
                        if (num11 > 1f)
                        {
                            flag10 = true;
                        }
                        value.Y = num12 + 54;
                        value.X = num16;
                        Microsoft.Xna.Framework.Color color4 = Lighting.GetColor(j, i);
                        switch (num5)
                        {
                        case 0:
                            color4 = Microsoft.Xna.Framework.Color.White;
                            break;
                        case 2:
                            color4 *= 0.5f;
                            break;
                        case 3:
                            color4 = Microsoft.Xna.Framework.Color.Transparent;
                            break;
                        }
                        if (color4 == Microsoft.Xna.Framework.Color.Transparent)
                        {
                            num11 -= 1f;
                        }
                        else
                        {
                            spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, value, color4 * (1f / num11), 0f, zero, 1f, SpriteEffects.None, 0f);
                            if (flag8)
                            {
                                if (flag10 && !flag4)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(18, value.Y, 16, 6), color4, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag4 = true;
                            }
                            if (flag9)
                            {
                                if (flag10 && !flag5)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2 + new Vector2(0f, 10f), new Microsoft.Xna.Framework.Rectangle(72, value.Y + 10, 16, 6), color4, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag5 = true;
                            }
                            if (flag7)
                            {
                                if (flag10 && !flag3)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2 + new Vector2(10f, 0f), new Microsoft.Xna.Framework.Rectangle(46, value.Y, 6, 16), color4, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag3 = true;
                            }
                            if (flag6)
                            {
                                if (flag10 && !flag2)
                                {
                                    spriteBatch.Draw(TextureAssets.WireNew.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(144, value.Y, 6, 16), color4, 0f, zero, 1f, SpriteEffects.None, 0f);
                                }
                                flag2 = true;
                            }
                        }
                    }
                }
                if (Main.tile[j, i].actuator() && (Lighting.Brightness(j, i) > 0f || num6 == 0))
                {
                    Microsoft.Xna.Framework.Color color5 = Lighting.GetColor(j, i);
                    switch (num6)
                    {
                    case 0:
                        color5 = Microsoft.Xna.Framework.Color.White;
                        break;
                    case 2:
                        color5 *= 0.5f;
                        break;
                    case 3:
                        color5 = Microsoft.Xna.Framework.Color.Transparent;
                        break;
                    }
                    spriteBatch.Draw(TextureAssets.Actuator.Value, new Vector2(j * 16 - (int)screenPosition.X, i * 16 - (int)screenPosition.Y) + zero2, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Actuator.Width(), TextureAssets.Actuator.Height()), color5 * num, 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
                }
                if (tile.active())
                {
                    ushort type = tile.type;
                    if (type == 423 && tile.frameY == 36)
                    {
                        DrawWiresSpecialTiles.Add(Tuple.Create(j, i, tile.type));
                    }
                }
            }
        }
        for (int k = 0; k < DrawWiresSpecialTiles.Count; k++)
        {
            Tuple<int, int, ushort> tuple = DrawWiresSpecialTiles[k];
            ushort type = tuple.Item3;
            if (type == 423)
            {
                Vector2 start = new Vector2(tuple.Item1 * 16 - 32 - 1, tuple.Item2 * 16 - 160 - 1) + zero2;
                Vector2 end = new Vector2(tuple.Item1 * 16 + 48 + 1, tuple.Item2 * 16 + 1) + zero2;
                Utils.DrawRectangle(spriteBatch, start, end, Microsoft.Xna.Framework.Color.LightSeaGreen, Microsoft.Xna.Framework.Color.LightSeaGreen, 2f);
            }
        }
        TimeLogger.DetailedDrawTime(34);
    }
 
    public static int ConvertPaintIdToTileShaderIndex(int paintIndexOnTile, bool isUsedForPaintingGrass, bool useWallShaderHacks)
    {
        if (paintIndexOnTile == 31)
        {
            return 0;
        }
        if (paintIndexOnTile == 30 && useWallShaderHacks)
        {
            return 43;
        }
        if (paintIndexOnTile >= 28)
        {
            return paintIndexOnTile + 12;
        }
        if (isUsedForPaintingGrass && paintIndexOnTile >= 1 && paintIndexOnTile <= 12)
        {
            return paintIndexOnTile + 27;
        }
        return paintIndexOnTile;
    }
 
    public static void ResetWindCounter(bool resetExtreme = false)
    {
        FastRandom fastRandom = FastRandom.CreateWithRandomSeed();
        windCounter = fastRandom.Next(900, 2701);
        if (resetExtreme)
        {
            extremeWindCounter = fastRandom.Next(10, 31);
        }
    }
 
    public static void NewLightning()
    {
        if (!DisableIntenseVisualEffects && !(shimmerAlpha > 0f))
        {
            if (rand.Next(3) == 0)
            {
                thunderDelay = rand.Next(1, 31);
            }
            else if (rand.Next(2) == 0)
            {
                thunderDelay = rand.Next(31, 121);
            }
            else
            {
                thunderDelay = rand.Next(11, 61);
            }
            thunderDistance = thunderDelay;
            lightningDecay = rand.NextFloat() * 0.05f + 0.008f;
            lightningSpeed = rand.NextFloat() * 0.05f + 0.05f;
        }
    }
 
    public void UpdateWeather(GameTime gameTime, int currentDayRateIteration)
    {
        if (netMode != 2 && currentDayRateIteration == 0)
        {
            bool flag = base.IsActive;
            if (thunderDelay > 0)
            {
                thunderDelay--;
                if (thunderDelay == 0)
                {
                    Vector2 center = player[myPlayer].Center;
                    float num = thunderDistance * 15;
                    if (rand.Next(2) == 0)
                    {
                        num *= -1f;
                    }
                    center.X += num;
                    int num2 = (int)(worldSurface * 16.0) - 500;
                    if (center.Y > (float)num2)
                    {
                        center.Y = num2;
                    }
                    if (flag)
                    {
                        SoundEngine.PlaySound(43, center);
                    }
                }
            }
            if (lightningSpeed > 0f)
            {
                lightning += lightningSpeed;
                if (lightning >= 1f)
                {
                    lightning = 1f;
                    lightningSpeed = 0f;
                }
                Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
                Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
            }
            else if (lightning > 0f)
            {
                lightning -= lightningDecay;
                Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
                Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
            }
            else if (thunderDelay <= 0 && (double)player[myPlayer].position.Y < rockLayer * 16.0 && atmo == 1f && !remixWorld)
            {
                if (IsItStorming)
                {
                    float num3 = 600f;
                    float num4 = 1600f;
                    if ((double)maxRaining > 0.8)
                    {
                        num3 *= 0.6f;
                        num4 *= 0.8f;
                    }
                    if ((double)maxRaining > 0.7)
                    {
                        num3 *= 0.7f;
                        num4 *= 0.9f;
                    }
                    if ((double)maxRaining > 0.6)
                    {
                        num3 *= 0.8f;
                        num4 *= 0.95f;
                    }
                    if ((double)Math.Abs(windSpeedTarget) > 0.7)
                    {
                        num3 *= 0.6f;
                        num4 *= 0.8f;
                    }
                    if ((double)Math.Abs(windSpeedTarget) > 0.6)
                    {
                        num3 *= 0.7f;
                        num4 *= 0.9f;
                    }
                    if ((double)Math.Abs(windSpeedTarget) > 0.5)
                    {
                        num3 *= 0.8f;
                        num4 *= 0.95f;
                    }
                    float num5 = rand.Next((int)num3, (int)num4);
                    num5 *= (1f - maxRaining + 1f) / 2f;
                    num5 *= (1f - windSpeedTarget + 1f) / 2f;
                    if (rand.Next((int)num5) == 0)
                    {
                        NewLightning();
                    }
                }
                else if ((double)GraveyardVisualIntensity >= 0.9)
                {
                    int maxValue = 120;
                    if (rand.Next(maxValue) == 0)
                    {
                        NewLightning();
                    }
                }
            }
        }
        float num6 = 0.8f;
        float num7 = 0.0003f;
        float num8 = windSpeedTarget * (1f + 5f / 9f * maxRaining);
        num7 += Math.Abs(num8 - windSpeedCurrent) * 0.0015f;
        if (windSpeedCurrent < num8)
        {
            windSpeedCurrent += num7;
            if (windSpeedCurrent > num8)
            {
                windSpeedCurrent = num8;
            }
        }
        else if (windSpeedCurrent > num8)
        {
            windSpeedCurrent -= num7;
            if (windSpeedCurrent < num8)
            {
                windSpeedCurrent = num8;
            }
        }
        if (netMode == 1 || (netMode != 2 && gameMenu))
        {
            return;
        }
        if (!CreativePowerManager.Instance.GetPower<CreativePowers.FreezeWindDirectionAndStrength>().Enabled)
        {
            if (LanternNight.LanternsUp)
            {
                return;
            }
            windCounter--;
            if (windCounter <= 0)
            {
                float num9 = 1f;
                if (windSpeedTarget < 0f)
                {
                    num9 = -1f;
                }
                if (rand.Next(4) == 0)
                {
                    windSpeedTarget += (float)rand.Next(-25, 26) * 0.001f;
                }
                else if (rand.Next(2) == 0)
                {
                    windSpeedTarget += (float)rand.Next(-50, 51) * 0.001f;
                }
                else
                {
                    windSpeedTarget += (float)rand.Next(-100, 101) * 0.001f;
                }
                extremeWindCounter--;
                if (extremeWindCounter <= 0)
                {
                    ResetWindCounter(resetExtreme: true);
                    if (rand.Next(30) < 13)
                    {
                        if (rand.Next(2) == 0)
                        {
                            windSpeedTarget = 0f;
                            windCounter = rand.Next(7200, 28801);
                        }
                        else
                        {
                            windSpeedTarget = (float)rand.Next(-200, 201) * 0.001f;
                        }
                    }
                    else if (rand.Next(20) < 13)
                    {
                        windSpeedTarget = (float)rand.Next(-400, 401) * 0.001f;
                    }
                    else
                    {
                        windSpeedTarget = (float)rand.Next(-850, 851) * 0.001f;
                    }
                    if ((double)Math.Abs(windSpeedTarget) > 0.3)
                    {
                        extremeWindCounter += rand.Next(5, 11);
                    }
                    if ((double)Math.Abs(windSpeedTarget) > 0.5)
                    {
                        extremeWindCounter += rand.Next(10, 21);
                    }
                    if ((double)Math.Abs(windSpeedTarget) > 0.7)
                    {
                        extremeWindCounter += rand.Next(15, 31);
                    }
                }
                else
                {
                    ResetWindCounter();
                }
                if (rand.Next(3) != 0 && ((num9 < 0f && windSpeedTarget > 0f) || (num9 > 0f && windSpeedTarget < 0f)))
                {
                    windSpeedTarget *= -1f;
                }
            }
            if (windSpeedTarget > num6)
            {
                windSpeedTarget = num6;
            }
            if (windSpeedTarget < 0f - num6)
            {
                windSpeedTarget = 0f - num6;
            }
        }
        if (rand.Next(60) == 0)
        {
            numCloudsTemp += rand.Next(-1, 2);
        }
        if ((float)rand.Next(1000) < 50f * cloudBGAlpha)
        {
            numCloudsTemp++;
        }
        if ((float)rand.Next(1300) < 25f * (1f - cloudBGAlpha))
        {
            numCloudsTemp--;
        }
        if ((float)rand.Next(1000) < 200f * cloudAlpha && numCloudsTemp < 100)
        {
            numCloudsTemp++;
        }
        if ((float)rand.Next(1000) < 50f * cloudAlpha)
        {
            numCloudsTemp++;
        }
        if (numCloudsTemp > 66 && rand.Next(100) == 0)
        {
            numCloudsTemp -= rand.Next(1, 3);
        }
        if (numCloudsTemp < 50 && rand.Next(100) == 0)
        {
            numCloudsTemp += rand.Next(1, 3);
        }
        if (cloudBGActive <= 0f && numCloudsTemp > 100 && cloudAlpha == 0f)
        {
            numCloudsTemp = 100;
        }
        if (numCloudsTemp < -20)
        {
            numCloudsTemp = -20;
        }
        if (cloudAlpha > 0f && (float)numClouds < 200f * cloudAlpha)
        {
            while ((float)numClouds < 200f * cloudAlpha)
            {
                numClouds += rand.Next(30);
                if (numClouds > 200)
                {
                    numClouds = 200;
                }
                if (numCloudsTemp < numClouds)
                {
                    numCloudsTemp = numClouds;
                }
            }
            if (netMode == 2)
            {
                NetMessage.SendData(7);
            }
        }
        weatherCounter--;
        if (weatherCounter > 0)
        {
            return;
        }
        if (rand.Next(2) == 0)
        {
            if (rand.Next(2) == 0)
            {
                numCloudsTemp += rand.Next(250);
            }
            else
            {
                numCloudsTemp += rand.Next(100);
            }
        }
        if (numCloudsTemp < 0)
        {
            numCloudsTemp = 0;
        }
        if (numCloudsTemp > 200)
        {
            numCloudsTemp = 200;
        }
        numClouds = numCloudsTemp;
        weatherCounter = rand.Next(3600, 10800);
        if (netMode == 2)
        {
            NetMessage.SendData(7);
        }
    }
 
    public void LoadBackground(int i)
    {
        //IL_000e: Unknown result type (might be due to invalid IL or missing references)
        if (i >= 0 && (int)TextureAssets.Background[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Background[i].Name, (AssetRequestMode)1);
            backgroundWidth[i] = TextureAssets.Background[i].Width();
            backgroundHeight[i] = TextureAssets.Background[i].Height();
            switch (i)
            {
            case 219:
            case 220:
            case 221:
            case 235:
            case 271:
            case 272:
            case 273:
            case 281:
                backgroundWidth[i] /= 2;
                backgroundHeight[i] /= 2;
                break;
            }
        }
    }
 
    public void LoadItem(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Item[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Item[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadNPC(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Npc[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Npc[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadProjectile(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Projectile[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Projectile[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadGore(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Gore[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Gore[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadWall(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Wall[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Wall[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadTiles(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Tile[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Tile[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadItemFlames(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.ItemFlame[i].State == 0)
        {
            try
            {
                Assets.Request<Texture2D>(TextureAssets.ItemFlame[i].Name, (AssetRequestMode)1);
            }
            catch
            {
            }
        }
    }
 
    public void LoadWings(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.Wings[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.Wings[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadHair(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.PlayerHair[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.PlayerHair[i].Name, (AssetRequestMode)1);
            Assets.Request<Texture2D>(TextureAssets.PlayerHairAlt[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadArmorHead(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.ArmorHead[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.ArmorHead[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadArmorBody(int i)
    {
        //IL_0037: Unknown result type (might be due to invalid IL or missing references)
        //IL_0010: Unknown result type (might be due to invalid IL or missing references)
        if (ArmorIDs.Body.Sets.UsesNewFramingCode[i])
        {
            if ((int)TextureAssets.ArmorBodyComposite[i].State == 0)
            {
                Assets.Request<Texture2D>(TextureAssets.ArmorBodyComposite[i].Name, (AssetRequestMode)1);
            }
        }
        else if ((int)TextureAssets.ArmorBody[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.FemaleBody[i].Name, (AssetRequestMode)1);
            Assets.Request<Texture2D>(TextureAssets.ArmorBody[i].Name, (AssetRequestMode)1);
            Assets.Request<Texture2D>(TextureAssets.ArmorArm[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadArmorLegs(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.ArmorLeg[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.ArmorLeg[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccHandsOn(int i)
    {
        //IL_0020: Unknown result type (might be due to invalid IL or missing references)
        //IL_004f: Unknown result type (might be due to invalid IL or missing references)
        bool flag = !ArmorIDs.HandOn.Sets.UsesNewFramingCode[i];
        if (ArmorIDs.HandOn.Sets.UsesOldFramingTexturesForWalking[i])
        {
            flag = true;
        }
        if (flag && (int)TextureAssets.AccHandsOn[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccHandsOn[i].Name, (AssetRequestMode)1);
        }
        if (ArmorIDs.HandOn.Sets.UsesNewFramingCode[i] && (int)TextureAssets.AccHandsOnComposite[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccHandsOnComposite[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccHandsOff(int i)
    {
        //IL_0010: Unknown result type (might be due to invalid IL or missing references)
        //IL_003f: Unknown result type (might be due to invalid IL or missing references)
        if (!ArmorIDs.HandOff.Sets.UsesNewFramingCode[i] && (int)TextureAssets.AccHandsOff[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccHandsOff[i].Name, (AssetRequestMode)1);
        }
        if (ArmorIDs.HandOff.Sets.UsesNewFramingCode[i] && (int)TextureAssets.AccHandsOffComposite[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccHandsOffComposite[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccBack(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccBack[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccBack[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccFront(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccFront[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccFront[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccShoes(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccShoes[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccShoes[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccWaist(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccWaist[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccWaist[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccShield(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccShield[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccShield[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccNeck(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccNeck[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccNeck[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccFace(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccFace[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccFace[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccBalloon(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccBalloon[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccBalloon[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadAccBeard(int i)
    {
        //IL_0007: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.AccBeard[i].State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.AccBeard[i].Name, (AssetRequestMode)1);
        }
    }
 
    public void LoadFlameRing()
    {
        //IL_0005: Unknown result type (might be due to invalid IL or missing references)
        if ((int)TextureAssets.FlameRing.State == 0)
        {
            Assets.Request<Texture2D>(TextureAssets.FlameRing.Name, (AssetRequestMode)1);
        }
    }
 
    protected void DrawSurfaceBG()
    {
        bool flag = false;
        if ((!remixWorld || (gameMenu && !WorldGen.remixWorldGen)) && (!WorldGen.remixWorldGen || !WorldGen.drunkWorldGen))
        {
            flag = true;
        }
        if (mapFullscreen)
        {
            flag = false;
        }
        Microsoft.Xna.Framework.Color colorOfSurfaceBackgroundsBase = ColorOfSurfaceBackgroundsBase;
        int num = 30;
        if (gameMenu)
        {
            num = 0;
        }
        if (WorldGen.drunkWorldGen)
        {
            num = -180;
        }
        float num2 = (float)worldSurface;
        if (num2 == 0f)
        {
            num2 = 1f;
        }
        _ = screenPosition;
        float num3 = screenPosition.Y + (float)(screenHeight / 2) - 600f;
        double num4 = (num3 - screenOff / 2f) / (num2 * 16f);
        num4 = 0f - MathHelper.Lerp((float)num4, 1f, 0f);
        num4 = (0f - num3 + screenOff / 2f) / (num2 * 16f);
        float num5 = 2f;
        int num6 = 0;
        float num7 = SkyManager.Instance.ProcessCloudAlpha() * atmo;
        if (flag && (double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int i = 0; i < 200; i++)
            {
                if (cloud[i].active && cloud[i].scale < 1f)
                {
                    Microsoft.Xna.Framework.Color color = cloud[i].cloudColor(ColorOfTheSkies);
                    float num8 = cloud[i].scale * 0.8f;
                    float num9 = (cloud[i].scale + 1f) / 2f * 0.9f;
                    color.R = (byte)((float)(int)color.R * num8);
                    color.G = (byte)((float)(int)color.G * num9);
                    float num10 = cloud[i].position.Y * ((float)screenHeight / 600f);
                    num10 = cloud[i].position.Y + (float)(int)(num4 * 750.0 + 830.0) + (float)(int)scAdj + (float)num6;
                    spriteBatch.Draw(TextureAssets.Cloud[cloud[i].type].Value, new Vector2(cloud[i].position.X + (float)TextureAssets.Cloud[cloud[i].type].Width() * 0.5f, num10 + (float)TextureAssets.Cloud[cloud[i].type].Height() * 0.5f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Cloud[cloud[i].type].Width(), TextureAssets.Cloud[cloud[i].type].Height()), color * num7, cloud[i].rotation, new Vector2((float)TextureAssets.Cloud[cloud[i].type].Width() * 0.5f, (float)TextureAssets.Cloud[cloud[i].type].Height() * 0.5f), cloud[i].scale, cloud[i].spriteDir, 0f);
                }
            }
        }
        if (invasionType == 4 && !SkyManager.Instance["Martian"].IsActive())
        {
            SkyManager.Instance.Activate("Martian", default(Vector2));
        }
        else if (invasionType != 4 && SkyManager.Instance["Martian"].IsActive())
        {
            SkyManager.Instance.Deactivate("Martian");
        }
        SkyManager.Instance.ResetDepthTracker();
        bgParallax = 0.15;
        int num11 = -180;
        bool flag2 = true;
        int num12 = 0;
        if (gameMenu)
        {
            num12 -= num11;
        }
        num6 = num12;
        num6 += num;
        if (!WorldGen.drunkWorldGen && flag && (double)(screenPosition.Y / 16f) <= worldSurface + 10.0)
        {
            if (BackgroundEnabled)
            {
                if (cloudBGActive > 0f)
                {
                    cloudBGAlpha += 0.0005f * (float)dayRate;
                    if (cloudBGAlpha > 1f)
                    {
                        cloudBGAlpha = 1f;
                    }
                }
                else
                {
                    cloudBGAlpha -= 0.0005f * (float)dayRate;
                    if (cloudBGAlpha < 0f)
                    {
                        cloudBGAlpha = 0f;
                    }
                }
                if (cloudBGAlpha > 0f)
                {
                    LoadBackground(cloudBG[0]);
                    LoadBackground(cloudBG[1]);
                    float num13 = cloudBGAlpha;
                    if (num13 > 1f)
                    {
                        num13 = 1f;
                    }
                    bgScale = 1.65f;
                    bgParallax = 0.09000000357627869;
                    if (base.IsActive && !gamePaused)
                    {
                        cloudBGX[0] += windSpeedCurrent * (float)bgParallax * 9f * (float)dayRate;
                    }
                    if (cloudBGX[0] > (float)backgroundWidth[cloudBG[0]] * bgScale)
                    {
                        cloudBGX[0] -= (float)backgroundWidth[cloudBG[0]] * bgScale;
                    }
                    if (cloudBGX[0] < (float)(-backgroundWidth[cloudBG[0]]) * bgScale)
                    {
                        cloudBGX[0] += (float)backgroundWidth[cloudBG[0]] * bgScale;
                    }
                    float num14 = (float)backgroundWidth[cloudBG[0]] * bgScale;
                    bgTopY = (int)(num4 * 900.0 + 600.0) + (int)scAdj + num6;
                    if (gameMenu)
                    {
                        bgTopY = -150 + num6;
                    }
                    bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, num14) - (double)(num14 / 2f) - (double)num14);
                    bgStartX += (int)cloudBGX[0];
                    bgLoops = screenWidth / (int)num14 + 2 + 2;
                    ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * num13;
                    SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
                    for (int j = 0; j < bgLoops; j++)
                    {
                        spriteBatch.Draw(TextureAssets.Background[cloudBG[0]].Value, new Vector2((float)bgStartX + num14 * (float)j, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[cloudBG[0]], backgroundHeight[cloudBG[0]]), ColorOfSurfaceBackgroundsModified * num7, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                    }
                    num13 = cloudBGAlpha * 1.5f;
                    if (num13 > 1f)
                    {
                        num13 = 1f;
                    }
                    ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * num13;
                    bgScale = 1.85f;
                    bgParallax = 0.12;
                    if (base.IsActive && !gamePaused)
                    {
                        cloudBGX[1] += windSpeedCurrent * (float)bgParallax * 9f * (float)dayRate;
                    }
                    if (cloudBGX[1] > (float)backgroundWidth[cloudBG[1]] * bgScale)
                    {
                        cloudBGX[1] -= (float)backgroundWidth[cloudBG[1]] * bgScale;
                    }
                    if (cloudBGX[1] < (float)(-backgroundWidth[cloudBG[1]]) * bgScale)
                    {
                        cloudBGX[1] += (float)backgroundWidth[cloudBG[1]] * bgScale;
                    }
                    num14 = (float)backgroundWidth[cloudBG[1]] * bgScale;
                    bgTopY = (int)(num4 * 1100.0 + 750.0) + (int)scAdj + num6;
                    if (gameMenu)
                    {
                        bgTopY = -50 + num6;
                    }
                    bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, num14) - (double)(num14 / 2f) - (double)num14);
                    bgStartX += (int)cloudBGX[1];
                    bgLoops = screenWidth / (int)num14 + 2 + 2;
                    SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
                    for (int k = 0; k < bgLoops; k++)
                    {
                        spriteBatch.Draw(TextureAssets.Background[cloudBG[1]].Value, new Vector2((float)bgStartX + num14 * (float)k, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[cloudBG[1]], backgroundHeight[cloudBG[1]]), ColorOfSurfaceBackgroundsModified * num7, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                    }
                }
                DrawSurfaceBG_BackMountainsStep1(num4, num5, num6);
            }
            cTop = bgTopY - 50;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int l = 0; l < 200; l++)
                {
                    if (cloud[l].active && (double)cloud[l].scale < 1.15 && cloud[l].scale >= 1f)
                    {
                        Microsoft.Xna.Framework.Color color2 = cloud[l].cloudColor(ColorOfTheSkies);
                        if (atmo < 1f)
                        {
                            color2 *= atmo;
                        }
                        float num15 = cloud[l].position.Y * ((float)screenHeight / 600f);
                        float num16 = (float)((double)(screenPosition.Y / 16f - 24f) / worldSurface);
                        if (num16 < 0f)
                        {
                            num16 = 0f;
                        }
                        if (num16 > 1f)
                        {
                            num16 = 1f;
                        }
                        if (gameMenu)
                        {
                            num16 = 1f;
                        }
                        spriteBatch.Draw(TextureAssets.Cloud[cloud[l].type].Value, new Vector2(cloud[l].position.X + (float)TextureAssets.Cloud[cloud[l].type].Width() * 0.5f, num15 + (float)TextureAssets.Cloud[cloud[l].type].Height() * 0.5f + cTop + 200f), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Cloud[cloud[l].type].Width(), TextureAssets.Cloud[cloud[l].type].Height()), color2 * num7, cloud[l].rotation, new Vector2((float)TextureAssets.Cloud[cloud[l].type].Width() * 0.5f, (float)TextureAssets.Cloud[cloud[l].type].Height() * 0.5f), cloud[l].scale, cloud[l].spriteDir, 0f);
                    }
                }
            }
            if (SceneMetrics.HolyTileCount > 0 && BackgroundEnabled)
            {
                bgParallax = 0.17;
                bgScale = 1.1f;
                bgTopY = (int)(num4 * 1400.0 + 900.0) + (int)scAdj + num6;
                SetBackgroundOffsets(18, num4, num6);
                bgScale *= num5;
                bgWidthScaled = (int)((double)(2100f * bgScale) * 1.05);
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
                bgLoops = screenWidth / bgWidthScaled + 2;
                if (gameMenu)
                {
                    bgTopY = 230 + num6;
                    bgStartX -= 500;
                }
                SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
                Microsoft.Xna.Framework.Color color3 = colorOfSurfaceBackgroundsBase;
                float num17 = (float)(SceneMetrics.HolyTileCount - SceneMetrics.HallowTileThreshold) / (float)(SceneMetrics.HallowTileMax - SceneMetrics.HallowTileThreshold);
                if (num17 > 0.5f)
                {
                    num17 = 0.5f;
                }
                else if (num17 < 0f)
                {
                    num17 = 0f;
                }
                color3.R = (byte)((float)(int)color3.R * num17);
                color3.G = (byte)((float)(int)color3.G * num17);
                color3.B = (byte)((float)(int)color3.B * num17);
                color3.A = (byte)((float)(int)color3.A * num17 * 0.8f);
                if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
                {
                    LoadBackground(18);
                    LoadBackground(19);
                    for (int m = 0; m < bgLoops; m++)
                    {
                        spriteBatch.Draw(TextureAssets.Background[18].Value, new Vector2(bgStartX + bgWidthScaled * m, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[18], backgroundHeight[18]), color3, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                        spriteBatch.Draw(TextureAssets.Background[19].Value, new Vector2(bgStartX + bgWidthScaled * m + 1900, bgTopY + 100), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[19], backgroundHeight[19]), color3, 0f, default(Vector2), bgScale * 0.9f, SpriteEffects.None, 0f);
                    }
                }
            }
            if (treeMntBGSet1[1] > -1)
            {
                LoadBackground(treeMntBGSet1[1]);
                bgParallax = 0.2;
                bgScale = 1.15f;
                bgScale *= num5;
                int num18 = backgroundWidth[treeMntBGSet1[1]];
                if (num18 == 0)
                {
                    num18 = 1;
                }
                bgWidthScaled = (int)((float)num18 * bgScale);
                bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
                bgLoops = screenWidth / bgWidthScaled + 2;
                if (treeMntBGSet1[1] == 172)
                {
                    bgLoops++;
                }
                bgTopY = (int)(num4 * 1400.0 + 1260.0) + (int)scAdj + num6;
            }
            if (BackgroundEnabled)
            {
                DrawSurfaceBG_BackMountainsStep2(num6);
            }
            cTop = (float)bgTopY * 1.01f - 150f;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int n = 0; n < 200; n++)
                {
                    if (cloud[n].active && cloud[n].scale >= 1.15f)
                    {
                        Microsoft.Xna.Framework.Color color4 = cloud[n].cloudColor(ColorOfTheSkies);
                        if (atmo < 1f)
                        {
                            color4 *= atmo;
                        }
                        float num19 = cloud[n].position.Y * ((float)screenHeight / 600f) - 100f;
                        float num20 = (float)((double)(screenPosition.Y / 16f - 24f) / worldSurface);
                        if (num20 < 0f)
                        {
                            num20 = 0f;
                        }
                        if (num20 > 1f)
                        {
                            num20 = 1f;
                        }
                        if (gameMenu)
                        {
                            num20 = 1f;
                        }
                        spriteBatch.Draw(TextureAssets.Cloud[cloud[n].type].Value, new Vector2(cloud[n].position.X + (float)TextureAssets.Cloud[cloud[n].type].Width() * 0.5f, num19 + (float)TextureAssets.Cloud[cloud[n].type].Height() * 0.5f + cTop), new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.Cloud[cloud[n].type].Width(), TextureAssets.Cloud[cloud[n].type].Height()), color4 * num7, cloud[n].rotation, new Vector2((float)TextureAssets.Cloud[cloud[n].type].Width() * 0.5f, (float)TextureAssets.Cloud[cloud[n].type].Height() * 0.5f), cloud[n].scale, cloud[n].spriteDir, 0f);
                    }
                }
            }
        }
        if (flag2)
        {
            num6 += num11;
        }
        if (flag)
        {
            for (int num21 = 0; num21 < bgAlphaFrontLayer.Length; num21++)
            {
                if (BackgroundEnabled)
                {
                    ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFrontLayer[num21];
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 0)
                    {
                        DrawSurfaceBG_Forest(num4, num5, num6, treeBGSet1);
                        DrawSurfaceBG_DrawChangeOverlay(0);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 10)
                    {
                        DrawSurfaceBG_Forest(num4, num5, num6, treeBGSet2);
                        DrawSurfaceBG_DrawChangeOverlay(1);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 11)
                    {
                        DrawSurfaceBG_Forest(num4, num5, num6, treeBGSet3);
                        DrawSurfaceBG_DrawChangeOverlay(2);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 12)
                    {
                        DrawSurfaceBG_Forest(num4, num5, num6, treeBGSet4);
                        DrawSurfaceBG_DrawChangeOverlay(3);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 1)
                    {
                        int[] bgTexIndexes = corruptBG;
                        DrawSurfaceBG_Corrupt(num4, num5, num6, bgTexIndexes);
                        DrawSurfaceBG_DrawChangeOverlay(4);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 2)
                    {
                        int[] bgTexIndexes2 = desertBG;
                        DrawSurfaceBG_Desert(num4, num5, num6, bgTexIndexes2);
                        DrawSurfaceBG_DrawChangeOverlay(9);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 3)
                    {
                        int[] bgTexIndexes3 = jungleBG;
                        DrawSurfaceBG_Jungle(num4, num5, num6, bgTexIndexes3);
                        DrawSurfaceBG_DrawChangeOverlay(5);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 4)
                    {
                        DrawSurfaceBG_DrawChangeOverlay(10);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 5)
                    {
                        DrawSurfaceBG_GoodEvilDesert(num4, num5, num6);
                        DrawSurfaceBG_DrawChangeOverlay(9);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 6)
                    {
                        int[] bgTexIndexes4 = hallowBG;
                        DrawSurfaceBG_Hallow(num4, num5, num6, bgTexIndexes4);
                        DrawSurfaceBG_DrawChangeOverlay(7);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 7)
                    {
                        int[] bgTexIndexes5 = snowBG;
                        DrawSurfaceBG_Snow(num4, num5, num6, bgTexIndexes5);
                        DrawSurfaceBG_DrawChangeOverlay(6);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 8)
                    {
                        int[] bgTexIndexes6 = crimsonBG;
                        DrawSurfaceBG_Crimson(num4, num5, num6, bgTexIndexes6);
                        DrawSurfaceBG_DrawChangeOverlay(8);
                    }
                    if (bgAlphaFrontLayer[num21] > 0f && num21 == 9)
                    {
                        int[] bgTexIndexes7 = mushroomBG;
                        DrawSurfaceBG_Mushroom(num4, num5, num6, bgTexIndexes7);
                        DrawSurfaceBG_DrawChangeOverlay(11);
                    }
                }
            }
        }
        if (flag2)
        {
            num6 -= num11;
        }
        float num22 = DrawSurfaceBG_GetFogPower();
        if (flag && num22 > 0f && !gameMenu && (double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            bgParallax = 0.1;
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, backgroundWidth[background]) - (double)(backgroundWidth[background] / 2));
            bgLoops = screenWidth / backgroundWidth[background] + 2;
            bgStartY = 0;
            bgLoopsY = 0;
            bgTopY = (int)((double)(0f - screenPosition.Y) / (worldSurface * 16.0 - 600.0) * 200.0);
            Texture2D value = TextureAssets.Background[49].Value;
            for (int num23 = 0; num23 < bgLoops; num23++)
            {
                bgStartX = 0;
                Microsoft.Xna.Framework.Color color5 = ColorOfTheSkies * num22 * atmo;
                int height = Math.Max(screenHeight + 210, value.Height);
                spriteBatch.Draw(value, new Microsoft.Xna.Framework.Rectangle(bgStartX + value.Width * num23, bgTopY, value.Width, height), color5);
            }
        }
        if (!mapFullscreen)
        {
            SkyManager.Instance.DrawRemainingDepth(spriteBatch);
        }
    }
 
    private static float DrawSurfaceBG_GetFogPower()
    {
        return Math.Max(cloudAlpha, GraveyardVisualIntensity * 0.92f);
    }
 
    private void DrawSurfaceBG_DrawBackMountainsLayer(int bgTextureIndex)
    {
        if (bgTextureIndex >= 0)
        {
            LoadBackground(bgTextureIndex);
            int num = DrawSurfaceBG_GetLayerYOffset(bgTextureIndex);
            bgTopY += num;
            for (int i = 0; i < bgLoops; i++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTextureIndex].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), GetBackgroundRect(bgTextureIndex), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
            bgTopY -= num;
        }
    }
 
    private int DrawSurfaceBG_GetLayerYOffset(int bgTextureIndex)
    {
        switch (bgTextureIndex)
        {
        case 59:
            return -550;
        case 93:
        case 168:
        case 169:
        case 170:
            return -50;
        case 171:
            return -100;
        case 172:
            return 130;
        case 176:
            return -760;
        case 177:
            return -200;
        case 179:
            return -100;
        case 180:
        case 181:
        case 182:
        case 183:
            return -350;
        case 246:
            return -150;
        case 247:
            return -150;
        case 263:
            return -700;
        case 269:
            return -100;
        case 270:
            return -50;
        case 271:
            return -300;
        case 272:
            return -380;
        case 277:
            return -260;
        case 278:
            return -120;
        case 280:
            return -170;
        case 281:
            return -300;
        case 283:
            return -800;
        default:
            return 0;
        }
    }
 
    private float GetForestToForestBackgroundLerperValue()
    {
        return (GlobalTimeWrappedHourly * ((float)Math.PI / 2f)).ToRotationVector2().X * 0.5f + 0.5f;
    }
 
    private void DrawSurfaceBG_BackMountainsStep1(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack)
    {
        Microsoft.Xna.Framework.Color colorOfSurfaceBackgroundsBase = ColorOfSurfaceBackgroundsBase;
        bgScale = 1f;
        bgTopY = (int)(backgroundTopMagicNumber * 1300.0 + 1090.0) + (int)scAdj + pushBGTopHack;
        bgScale *= bgGlobalScaleMultiplier;
        bgParallax = 0.15;
        bgWidthScaled = (int)(1024f * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (bgWidthScaled == 0)
        {
            bgWidthScaled = 1024;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if (gameMenu)
        {
            bgTopY = 100 + pushBGTopHack;
        }
        if (!((double)screenPosition.Y < worldSurface * 16.0 + 16.0))
        {
            return;
        }
        if (bgAlphaFarBackLayer[0] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[0];
            DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet1[0]);
        }
        if (bgAlphaFarBackLayer[10] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[10];
            DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet2[0]);
        }
        if (bgAlphaFarBackLayer[11] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[11];
            DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet3[0]);
        }
        if (bgAlphaFarBackLayer[12] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[12];
            DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet4[0]);
        }
        if (bgAlphaFarBackLayer[1] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[1];
            if (WorldGen.desertBG != 4)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(23);
            }
        }
        if (bgAlphaFarBackLayer[2] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[2];
            DrawSurfaceBG_DrawBackMountainsLayer(24);
        }
        if (bgAlphaFarBackLayer[4] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[4];
            DrawSurfaceBG_DrawBackMountainsLayer(snowMntBG[0]);
        }
        if (bgAlphaFarBackLayer[5] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[5];
            if (WorldGen.crimsonBG != 5)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(24);
            }
        }
        if (bgAlphaFarBackLayer[6] > 0f && WorldGen.hallowBG == 3)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[6];
            DrawSurfaceBG_DrawBackMountainsLayer(246);
        }
        SkyManager.Instance.DrawToDepth(spriteBatch, 5f);
    }
 
    private void DrawSurfaceBG_BackMountainsStep2(int pushBGTopHack)
    {
        if (gameMenu)
        {
            bgTopY = 230 + pushBGTopHack;
            bgStartX -= 500;
        }
        Microsoft.Xna.Framework.Color colorOfSurfaceBackgroundsBase = ColorOfSurfaceBackgroundsBase;
        UpdateOceanWaterLineForAmbience();
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        if (!((double)screenPosition.Y < worldSurface * 16.0 + 16.0))
        {
            return;
        }
        if (bgAlphaFarBackLayer[0] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[0];
            if (treeMntBGSet1[1] > -1)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet1[1]);
            }
        }
        if (bgAlphaFarBackLayer[1] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[1];
            if (WorldGen.desertBG != 4)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(22);
            }
        }
        if (bgAlphaFarBackLayer[2] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[2];
            DrawSurfaceBG_DrawBackMountainsLayer(25);
        }
        if (bgAlphaFarBackLayer[3] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[3];
            DrawSurfaceBG_DrawBackMountainsLayer(oceanBG);
        }
        if (bgAlphaFarBackLayer[4] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[4];
            DrawSurfaceBG_DrawBackMountainsLayer(snowMntBG[1]);
        }
        if (bgAlphaFarBackLayer[5] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[5];
            if (WorldGen.crimsonBG != 5)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(42);
            }
        }
        if (bgAlphaFarBackLayer[6] > 0f && WorldGen.hallowBG == 3)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[6];
            DrawSurfaceBG_DrawBackMountainsLayer(247);
        }
        if (bgAlphaFarBackLayer[10] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[10];
            if (treeMntBGSet2[1] > -1)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet2[1]);
            }
        }
        if (bgAlphaFarBackLayer[11] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[11];
            if (treeMntBGSet3[1] > -1)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet3[1]);
            }
        }
        if (bgAlphaFarBackLayer[12] > 0f)
        {
            ColorOfSurfaceBackgroundsModified = colorOfSurfaceBackgroundsBase * bgAlphaFarBackLayer[12];
            if (treeMntBGSet4[1] > -1)
            {
                DrawSurfaceBG_DrawBackMountainsLayer(treeMntBGSet4[1]);
            }
        }
    }
 
    private void UpdateOceanWaterLineForAmbience()
    {
        int num = DrawSurfaceBG_GetLayerYOffset(oceanBG);
        int num2 = 0;
        switch (oceanBG)
        {
        case 28:
        case 110:
        case 111:
        case 209:
        case 210:
            num2 = 102;
            break;
        case 283:
            num2 = 124;
            break;
        }
        float yScreenPosition = (float)(bgTopY + num) + (float)num2 * bgScale;
        AmbientSkyDrawCache.Instance.SetOceanLineInfo(yScreenPosition, bgAlphaFarBackLayer[3]);
    }
 
    private void DrawSurfaceBG_Mushroom(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        float num = 0.33f;
        Vector3 vector = new Vector3(0.1f, 0.15f, 0.3f);
        float num2 = 0.5f;
        Vector3 vector2 = new Vector3(0.1f, 0.175f, 0.3f);
        float num3 = 0.75f;
        Vector3 vector3 = new Vector3(0.125f, 0.2f, 0.3f);
        num = 0.5f;
        num2 = 0.625f;
        num3 = 0.75f;
        vector *= 3f;
        vector2 *= 3f;
        vector3 *= 3f;
        float num4 = (float)(int)ColorOfSurfaceBackgroundsModified.A / 255f;
        Microsoft.Xna.Framework.Color colorOfSurfaceBackgroundsModified = ColorOfSurfaceBackgroundsModified;
        float num5 = (float)rand.Next(28, 42) * 0.001f;
        num5 += (float)(270 - mouseTextColor) / 5000f;
        float x = vector.X;
        float num6 = vector.Y + num5 / 2f;
        float num7 = vector.Z + num5;
        x *= 255f;
        num6 *= 255f;
        num7 *= 255f;
        x *= num * num4;
        num6 *= num * num4;
        num7 *= num * num4;
        if (x > 255f)
        {
            x = 255f;
        }
        if (num6 > 255f)
        {
            num6 = 255f;
        }
        if (num7 > 255f)
        {
            num7 = 255f;
        }
        if (x > (float)(int)colorOfSurfaceBackgroundsModified.R)
        {
            colorOfSurfaceBackgroundsModified.R = (byte)x;
        }
        if (num6 > (float)(int)colorOfSurfaceBackgroundsModified.G)
        {
            colorOfSurfaceBackgroundsModified.G = (byte)num6;
        }
        if (num7 > (float)(int)colorOfSurfaceBackgroundsModified.B)
        {
            colorOfSurfaceBackgroundsModified.B = (byte)num7;
        }
        bgScale = 1.25f;
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[0]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
        bgParallax = 0.4;
        SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1400.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
        if (gameMenu)
        {
            bgTopY = 320 + pushBGTopHack;
        }
        if (bgWidthScaled != 0)
        {
            bgLoops = screenWidth / bgWidthScaled + 2;
        }
        if (TextureAssets.Background[bgTexIndexes[0]].Value == null)
        {
            return;
        }
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int i = 0; i < bgLoops; i++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), GetBackgroundRect(bgTexIndexes[0]), colorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
        colorOfSurfaceBackgroundsModified = ColorOfSurfaceBackgroundsModified;
        num5 = (float)rand.Next(28, 42) * 0.001f;
        num5 += (float)(270 - mouseTextColor) / 5000f;
        x = vector2.X;
        num6 = vector2.Y + num5 / 2f;
        num7 = vector2.Z + num5;
        x *= 255f;
        num6 *= 255f;
        num7 *= 255f;
        x *= num2 * num4;
        num6 *= num2 * num4;
        num7 *= num2 * num4;
        if (x > 255f)
        {
            x = 255f;
        }
        if (num6 > 255f)
        {
            num6 = 255f;
        }
        if (num7 > 255f)
        {
            num7 = 255f;
        }
        if (x > (float)(int)colorOfSurfaceBackgroundsModified.R)
        {
            colorOfSurfaceBackgroundsModified.R = (byte)x;
        }
        if (num6 > (float)(int)colorOfSurfaceBackgroundsModified.G)
        {
            colorOfSurfaceBackgroundsModified.G = (byte)num6;
        }
        if (num7 > (float)(int)colorOfSurfaceBackgroundsModified.B)
        {
            colorOfSurfaceBackgroundsModified.B = (byte)num7;
        }
        bgScale = 1.32f;
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[1]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
        bgParallax = 0.43;
        SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1675.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
        if (gameMenu)
        {
            bgTopY = 400 + pushBGTopHack;
            bgStartX -= 80;
        }
        if (bgWidthScaled == 0)
        {
            return;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int j = 0; j < bgLoops; j++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), GetBackgroundRect(bgTexIndexes[1]), colorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
        colorOfSurfaceBackgroundsModified = ColorOfSurfaceBackgroundsModified;
        num5 = (float)rand.Next(28, 42) * 0.001f;
        num5 += (float)(270 - mouseTextColor) / 3000f;
        x = vector3.X;
        num6 = vector3.Y + num5 / 2f;
        num7 = vector3.Z + num5;
        x *= 255f * num4 * num3;
        num6 *= 255f * num4 * num3;
        num7 *= 255f * num4 * num3;
        if (x > 255f)
        {
            x = 255f;
        }
        if (num6 > 255f)
        {
            num6 = 255f;
        }
        if (num7 > 255f)
        {
            num7 = 255f;
        }
        if (x > (float)(int)colorOfSurfaceBackgroundsModified.R)
        {
            colorOfSurfaceBackgroundsModified.R = (byte)x;
        }
        if (num6 > (float)(int)colorOfSurfaceBackgroundsModified.G)
        {
            colorOfSurfaceBackgroundsModified.G = (byte)num6;
        }
        if (num7 > (float)(int)colorOfSurfaceBackgroundsModified.B)
        {
            colorOfSurfaceBackgroundsModified.B = (byte)num7;
        }
        bgScale = 1.36f;
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        bgParallax = 0.49;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 1950.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        if (bgWidthScaled == 0)
        {
            return;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), GetBackgroundRect(bgTexIndexes[2]), colorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f);
    }
 
    private void DrawSurfaceBG_Crimson(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        if (bgTexIndexes[0] > -1)
        {
            bgScale = 1.25f;
            bgParallax = 0.4;
            bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1500.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[0]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (bgTexIndexes[0] == 105)
            {
                bgTopY += 50;
            }
            if (bgTexIndexes[0] == 174)
            {
                bgTopY -= 350;
            }
            if (gameMenu)
            {
                bgTopY = 320 + pushBGTopHack;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int i = 0; i < bgLoops; i++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[0]], backgroundHeight[bgTexIndexes[0]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[1] > -1)
        {
            bgScale = 1.31f;
            bgParallax = 0.43;
            bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1750.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[1]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (gameMenu)
            {
                bgTopY = 400 + pushBGTopHack;
                bgStartX -= 80;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int j = 0; j < bgLoops; j++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[1]], backgroundHeight[bgTexIndexes[1]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        bgScale = 1.34f;
        bgParallax = 0.49;
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2000.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if (bgTexIndexes[2] == 175)
        {
            bgStartX -= 1000;
            bgTopY -= 400;
            bgLoops++;
        }
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[2]], backgroundHeight[bgTexIndexes[2]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void DrawSurfaceBG_Snow(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        if (bgTexIndexes[0] >= 0)
        {
            bgScale = 1.25f;
            bgParallax = 0.4;
            bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1500.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[0]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (gameMenu)
            {
                bgTopY = 320 + pushBGTopHack;
            }
            bgTopY += DrawSurfaceBG_GetLayerYOffset(bgTexIndexes[0]);
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int i = 0; i < bgLoops; i++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[0]], backgroundHeight[bgTexIndexes[0]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[1] >= 0)
        {
            bgScale = 1.31f;
            bgParallax = 0.43;
            bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1750.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[1]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (gameMenu)
            {
                bgTopY = 400 + pushBGTopHack;
                bgStartX -= 80;
            }
            bgTopY += DrawSurfaceBG_GetLayerYOffset(bgTexIndexes[1]);
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int j = 0; j < bgLoops; j++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[1]], backgroundHeight[bgTexIndexes[1]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[2] < 0)
        {
            return;
        }
        bgScale = 1.34f;
        bgParallax = 0.49;
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2000.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        bgTopY += DrawSurfaceBG_GetLayerYOffset(bgTexIndexes[2]);
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[2]], backgroundHeight[bgTexIndexes[2]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void SetBackgroundOffsets(int backgroundID, double backgroundTopMagicNumber, int pushBGTopHack)
    {
        int num = 0;
        int num2 = 0;
        switch (backgroundID)
        {
        case 18:
            if (WorldGen.hallowBG == 3)
            {
                bgParallax = 0.17;
                bgScale = 1.1f;
                num = 1400;
                num2 = 1100;
            }
            break;
        case 258:
            bgScale = 1.25f;
            bgParallax = 0.23;
            num = 1800;
            num2 = 850;
            break;
        case 259:
            bgScale = 1.31f;
            bgParallax = 0.33;
            num = 1950;
            num2 = 1500;
            break;
        case 260:
            bgScale = 1.34f;
            bgParallax = 0.4;
            num = 2100;
            num2 = 1650;
            break;
        case 263:
            bgScale = 1.25f;
            bgParallax = 0.23;
            num = 1800;
            num2 = 1450;
            break;
        case 264:
            bgScale = 1.31f;
            bgParallax = 0.33;
            num = 1950;
            num2 = 1700;
            break;
        case 265:
            bgScale = 1.34f;
            bgParallax = 0.4;
            num = 2100;
            num2 = 2000;
            break;
        case 267:
            bgScale = 1.25f;
            bgParallax = 0.23;
            num = 1700;
            num2 = 1300;
            break;
        case 266:
            bgScale = 1.31f;
            bgParallax = 0.33;
            num = 1950;
            num2 = 1600;
            break;
        case 268:
            bgScale = 1.34f;
            bgParallax = 0.41;
            num = 2100;
            num2 = 1850;
            break;
        case 248:
            bgScale = 1.3f;
            bgParallax = 0.37;
            num = 1800;
            num2 = 1100;
            break;
        case 249:
            bgScale = 1.4f;
            bgParallax = 0.43;
            num = 1950;
            num2 = 1200;
            break;
        case 250:
            bgScale = 1.7f;
            bgParallax = 0.49;
            num = 2000;
            num2 = 1000;
            break;
        case 255:
            bgScale = 1.15f;
            bgParallax = 0.25;
            num = 1800;
            num2 = 1450;
            break;
        case 256:
            bgScale = 1.21f;
            bgParallax = 0.32;
            num = 1950;
            num2 = 1550;
            break;
        case 257:
            bgScale = 1.34f;
            bgParallax = 0.4;
            num = 2100;
            num2 = 1550;
            break;
        case 240:
            bgScale = 1.15f;
            bgParallax = 0.3;
            num = 1800;
            num2 = 1500;
            break;
        case 241:
            bgScale = 1.21f;
            bgParallax = 0.43;
            num = 1950;
            num2 = 1300;
            break;
        case 242:
            bgScale = 1.34f;
            bgParallax = 0.49;
            num = 2100;
            num2 = 1400;
            break;
        case 243:
            bgScale = 1.15f;
            bgParallax = 0.25;
            num = 1800;
            num2 = 1400;
            break;
        case 244:
            bgScale = 1.21f;
            bgParallax = 0.35;
            num = 1950;
            num2 = 1550;
            break;
        case 245:
            bgScale = 1.24f;
            bgParallax = 0.45;
            num = 2100;
            num2 = 1650;
            break;
        case 273:
            bgParallax = 0.49000000953674316;
            num = 2100;
            num2 = 1560;
            break;
        case 234:
            bgParallax = 0.23;
            num = 1700;
            num2 = 1150;
            break;
        case 235:
            bgParallax = 0.33;
            num = 1950;
            num2 = 1550;
            break;
        case 236:
            bgParallax = 0.41;
            num = 2100;
            num2 = 2000;
            break;
        case 279:
            bgScale = 2.5f;
            bgParallax = 0.3499999940395355;
            num = 1850;
            num2 = 1750;
            break;
        case 282:
            bgScale = 2.6f;
            bgParallax = 0.25;
            num = 1800;
            num2 = 1340;
            break;
        case 261:
            bgParallax = 0.27;
            break;
        case 262:
            bgParallax = 0.4;
            break;
        case 219:
            bgParallax = 0.25;
            break;
        case 220:
            bgParallax = 0.34;
            break;
        case 221:
            bgParallax = 0.43;
            break;
        case 222:
            num = 1800;
            num2 = 1400;
            break;
        case 223:
            num = 2150;
            num2 = 1850;
            break;
        case 224:
            num = 2500;
            num2 = 2400;
            break;
        case 237:
            num = 1800;
            num2 = 1500;
            break;
        case 238:
            num = 1950;
            num2 = 1500;
            break;
        case 239:
            num = 2100;
            num2 = 1900;
            break;
        case 284:
            bgParallax = 0.23;
            num = 1600;
            num2 = 900;
            break;
        case 285:
            bgParallax = 0.36;
            num = 1900;
            num2 = 960;
            break;
        case 286:
            bgParallax = 0.42;
            num = 2100;
            num2 = 1200;
            break;
        case 287:
            bgParallax = 0.21;
            num = 1700;
            num2 = 1560;
            break;
        case 288:
            bgParallax = 0.33;
            num = 1950;
            num2 = 1730;
            break;
        case 289:
            bgParallax = 0.41;
            num = 2100;
            num2 = 1400;
            break;
        case 207:
            bgParallax = 0.32;
            break;
        }
        if (num != 0 || num2 != 0)
        {
            bgTopY = (int)(backgroundTopMagicNumber * (double)num + (double)num2) + (int)scAdj + pushBGTopHack;
        }
    }
 
    private void DrawSurfaceBG_Hallow(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        if (bgTexIndexes[0] > 0)
        {
            bgScale = 1.25f;
            bgParallax = 0.4;
            bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1500.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[0]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1.2f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (gameMenu)
            {
                bgTopY = 320 + pushBGTopHack;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int i = 0; i < bgLoops; i++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), GetBackgroundRect(bgTexIndexes[0]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[1] > 0)
        {
            bgScale = 1.31f;
            bgParallax = 0.43;
            bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1750.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[1]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (gameMenu)
            {
                bgTopY = 400 + pushBGTopHack;
                bgStartX -= 80;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int j = 0; j < bgLoops; j++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), GetBackgroundRect(bgTexIndexes[1]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[2] <= 0)
        {
            return;
        }
        bgScale = 1.34f;
        bgParallax = 0.49;
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2000.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), GetBackgroundRect(bgTexIndexes[2]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void DrawSurfaceBG_GoodEvilDesert(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack)
    {
        LoadBackground(26);
        bgScale = 1.25f;
        bgScale *= bgGlobalScaleMultiplier;
        bgWidthScaled = (int)((float)backgroundWidth[26] * bgScale);
        bgParallax = 0.37;
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1750.0) + (int)scAdj + pushBGTopHack;
        if (gameMenu)
        {
            bgTopY = 320 + pushBGTopHack;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int i = 0; i < bgLoops; i++)
            {
                spriteBatch.Draw(TextureAssets.Background[26].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[26], backgroundHeight[26]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
        bgScale = 1.34f;
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(27);
        bgWidthScaled = (int)((float)backgroundWidth[27] * bgScale);
        bgParallax = 0.49;
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2150.0) + (int)scAdj + pushBGTopHack;
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int j = 0; j < bgLoops; j++)
            {
                spriteBatch.Draw(TextureAssets.Background[27].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[27], backgroundHeight[27]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void DrawSurfaceBG_Jungle(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        LoadBackground(bgTexIndexes[0]);
        bgScale = 1.25f;
        bgScale *= bgGlobalScaleMultiplier;
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
        bgParallax = 0.4;
        SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1660.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
        if (gameMenu)
        {
            bgTopY = 320 + pushBGTopHack;
        }
        if (bgTexIndexes[0] == 59)
        {
            bgTopY -= 200;
        }
        bgTopY += DrawSurfaceBG_GetLayerYOffset(bgTexIndexes[0]);
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int i = 0; i < bgLoops; i++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), GetBackgroundRect(bgTexIndexes[0]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
        LoadBackground(bgTexIndexes[1]);
        bgScale = 1.31f;
        bgScale *= bgGlobalScaleMultiplier;
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
        bgParallax = 0.43;
        SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1840.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
        if (gameMenu)
        {
            bgTopY = 400 + pushBGTopHack;
            bgStartX -= 80;
        }
        if (bgTexIndexes[1] == 60)
        {
            bgTopY -= 175;
        }
        bgTopY += DrawSurfaceBG_GetLayerYOffset(bgTexIndexes[1]);
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int j = 0; j < bgLoops; j++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), GetBackgroundRect(bgTexIndexes[1]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.FlipHorizontally, 0f);
            }
        }
        bgScale = 1.34f;
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        bgParallax = 0.49;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2060.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        if (bgTexIndexes[2] == 61)
        {
            bgTopY -= 150;
        }
        bgTopY += DrawSurfaceBG_GetLayerYOffset(bgTexIndexes[2]);
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), GetBackgroundRect(bgTexIndexes[2]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void DrawSurfaceBG_Desert(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        if (bgTexIndexes[0] > 0)
        {
            bgScale = 1.25f;
            bgParallax = 0.37;
            bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1750.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
            LoadBackground(bgTexIndexes[0]);
            bgScale *= bgGlobalScaleMultiplier;
            float num = (float)backgroundWidth[bgTexIndexes[0]] * bgScale;
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, num) - (double)(num / 2f));
            if (gameMenu)
            {
                bgTopY = 320 + pushBGTopHack;
            }
            bgLoops = screenWidth / (int)num + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int i = 0; i < bgLoops; i++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2((float)bgStartX + num * (float)i, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[0]], backgroundHeight[bgTexIndexes[0]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[1] > 0)
        {
            bgScale = 1.34f;
            bgParallax = 0.49;
            bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2150.0) + (int)scAdj + pushBGTopHack;
            SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
            bgScale *= bgGlobalScaleMultiplier;
            LoadBackground(bgTexIndexes[1]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (gameMenu)
            {
                bgTopY = 480 + pushBGTopHack;
                bgStartX -= 120;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int j = 0; j < bgLoops; j++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[1]], backgroundHeight[bgTexIndexes[1]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                }
            }
        }
        if (bgTexIndexes[2] <= 0)
        {
            return;
        }
        bgScale = 1.34f;
        bgParallax = 0.49;
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2150.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[2]], backgroundHeight[bgTexIndexes[2]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void DrawSurfaceBG_DrawChangeOverlay(int backgroundAreaId)
    {
        Texture2D value = TextureAssets.MagicPixel.Value;
        float flashPower = WorldGen.BackgroundsCache.GetFlashPower(backgroundAreaId);
        Microsoft.Xna.Framework.Color color = Microsoft.Xna.Framework.Color.Black * flashPower;
        spriteBatch.Draw(value, new Microsoft.Xna.Framework.Rectangle(0, 0, screenWidth, screenHeight), color);
    }
 
    private void DrawSurfaceBG_Corrupt(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        bgScale = 1.25f;
        bgParallax = 0.4;
        bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1500.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[0]);
        if (backgroundWidth[bgTexIndexes[0]] == 0 || backgroundHeight[bgTexIndexes[0]] == 0)
        {
            return;
        }
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 320 + pushBGTopHack;
        }
        if (bgTexIndexes[0] == 56)
        {
            bgTopY -= 100;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int i = 0; i < bgLoops; i++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[0]].Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[0]], backgroundHeight[bgTexIndexes[0]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
        bgScale = 1.31f;
        bgParallax = 0.43;
        bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1750.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[1]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 400 + pushBGTopHack;
            bgStartX -= 80;
        }
        if (bgTexIndexes[0] == 56)
        {
            bgTopY -= 100;
        }
        if (bgWidthScaled == 0)
        {
            bgWidthScaled = 1;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            try
            {
                Texture2D value = TextureAssets.Background[bgTexIndexes[1]].Value;
                if (value != null)
                {
                    for (int j = 0; j < bgLoops; j++)
                    {
                        spriteBatch.Draw(value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[1]], backgroundHeight[bgTexIndexes[1]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.FlipHorizontally, 0f);
                    }
                }
            }
            catch
            {
                LoadBackground(bgTexIndexes[1]);
            }
        }
        bgScale = 1.34f;
        bgParallax = 0.49;
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2000.0) + (int)scAdj + pushBGTopHack;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        LoadBackground(bgTexIndexes[2]);
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        if (bgWidthScaled == 0)
        {
            bgWidthScaled = 150;
        }
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        if (bgTexIndexes[0] == 56)
        {
            bgTopY -= 100;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), new Microsoft.Xna.Framework.Rectangle(0, 0, backgroundWidth[bgTexIndexes[2]], backgroundHeight[bgTexIndexes[2]]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private Microsoft.Xna.Framework.Rectangle? GetBackgroundRect(int backgroundTextureIndex)
    {
        int num = 0;
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(0, 0, 1, 1);
        switch (backgroundTextureIndex)
        {
        case 235:
            num = (int)(GetBackgroundCounter() / 20) % 4;
            rectangle = TextureAssets.Background[backgroundTextureIndex].Frame(2, 2, num % 2, num / 2);
            rectangle.Inflate(0, -2);
            return rectangle;
        case 219:
        case 220:
        case 221:
        case 271:
        case 272:
        case 273:
            num = (int)(GetBackgroundCounter() / 15) % 4;
            rectangle = TextureAssets.Background[backgroundTextureIndex].Frame(2, 2, num % 2, num / 2);
            rectangle.Inflate(0, -2);
            return rectangle;
        case 281:
            num = (int)(GetBackgroundCounter() / 5) % 4;
            rectangle = TextureAssets.Background[backgroundTextureIndex].Frame(2, 2, num % 2, num / 2);
            rectangle.Inflate(0, -2);
            return rectangle;
        default:
            return null;
        }
    }
 
    private uint GetBackgroundCounter()
    {
        if (!gameMenu)
        {
            return GameUpdateCount;
        }
        return (uint)(GlobalTimeWrappedHourly * 40f);
    }
 
    private void DrawSurfaceBG_Forest(double backgroundTopMagicNumber, float bgGlobalScaleMultiplier, int pushBGTopHack, int[] bgTexIndexes)
    {
        bgScale = 1.25f;
        bgParallax = 0.4;
        bgTopY = (int)(backgroundTopMagicNumber * 1800.0 + 1500.0) + (int)scAdj + pushBGTopHack;
        if (bgTexIndexes[0] == 91)
        {
            bgParallax = 0.27000001072883606;
            bgScale = 1.2f;
        }
        if (bgTexIndexes[0] == 173)
        {
            bgParallax = 0.25;
            bgScale = 1.3f;
        }
        if (bgTexIndexes[0] == 178)
        {
            bgParallax = 0.30000001192092896;
            bgScale = 1.2f;
        }
        if (bgTexIndexes[0] == 184)
        {
            bgParallax = 0.25;
            bgScale = 1.2f;
        }
        if (bgTexIndexes[0] == 282)
        {
            bgScale = 1.4f;
        }
        SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
        bgScale *= bgGlobalScaleMultiplier;
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        if (bgTexIndexes[0] >= 0)
        {
            SetBackgroundOffsets(bgTexIndexes[0], backgroundTopMagicNumber, pushBGTopHack);
            LoadBackground(bgTexIndexes[0]);
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[0]] * bgScale);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            if (bgTexIndexes[0] == 91)
            {
                bgTopY = (int)(backgroundTopMagicNumber * 1600.0 + 1400.0) + (int)scAdj + pushBGTopHack;
            }
            if (bgTexIndexes[0] == 173)
            {
                bgTopY = (int)(backgroundTopMagicNumber * 1600.0 + 1400.0) + (int)scAdj + pushBGTopHack;
            }
            if (bgTexIndexes[0] == 184)
            {
                bgTopY = (int)(backgroundTopMagicNumber * 1600.0 + 1400.0) + (int)scAdj + pushBGTopHack;
            }
            if (gameMenu)
            {
                bgTopY = 320 + pushBGTopHack;
            }
            if (bgTexIndexes[0] == 50)
            {
                bgTopY -= 50;
            }
            if (bgTexIndexes[0] == 53)
            {
                bgTopY -= 100;
            }
            if (bgTexIndexes[0] == 91)
            {
                bgTopY += 200;
            }
            if (bgTexIndexes[0] == 173)
            {
                bgTopY += 200;
            }
            if (bgTexIndexes[0] == 178)
            {
                bgTopY += 75;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int i = 0; i < bgLoops; i++)
                {
                    if (bgTexIndexes[0] != -1)
                    {
                        Asset<Texture2D> val = TextureAssets.Background[bgTexIndexes[0]];
                        int num = bgTexIndexes[0];
                        if (num == 173)
                        {
                            int num2 = (int)(GetBackgroundCounter() / 10);
                            num2 %= 4;
                            int num3 = 251 + num2;
                            LoadBackground(num3);
                            val = TextureAssets.Background[num3];
                        }
                        if (val.Value != null)
                        {
                            spriteBatch.Draw(val.Value, new Vector2(bgStartX + bgWidthScaled * i, bgTopY), GetBackgroundRect(bgTexIndexes[0]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
                        }
                    }
                }
            }
        }
        if (bgTexIndexes[1] >= 0)
        {
            LoadBackground(bgTexIndexes[1]);
            bgScale = 1.31f;
            bgScale *= bgGlobalScaleMultiplier;
            bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[1]] * bgScale);
            if (bgWidthScaled == 0)
            {
                bgWidthScaled = 1;
            }
            bgParallax = 0.43;
            SetBackgroundOffsets(bgTexIndexes[1], backgroundTopMagicNumber, pushBGTopHack);
            SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
            bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
            bgTopY = (int)(backgroundTopMagicNumber * 1950.0 + 1750.0) + (int)scAdj + pushBGTopHack;
            if (gameMenu)
            {
                bgTopY = 400 + pushBGTopHack;
                bgStartX -= 80;
            }
            if (bgTexIndexes[1] == 51)
            {
                bgTopY -= 50;
            }
            if (bgTexIndexes[1] == 54)
            {
                bgTopY -= 100;
            }
            bgLoops = screenWidth / bgWidthScaled + 2;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                for (int j = 0; j < bgLoops; j++)
                {
                    spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[1]].Value, new Vector2(bgStartX + bgWidthScaled * j, bgTopY), GetBackgroundRect(bgTexIndexes[1]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.FlipHorizontally, 0f);
                }
            }
        }
        if (bgTexIndexes[2] < 0)
        {
            return;
        }
        LoadBackground(bgTexIndexes[2]);
        bgScale = 1.34f;
        bgScale *= bgGlobalScaleMultiplier;
        bgParallax = 0.49;
        SetBackgroundOffsets(bgTexIndexes[2], backgroundTopMagicNumber, pushBGTopHack);
        SkyManager.Instance.DrawToDepth(spriteBatch, 1f / (float)bgParallax);
        if (bgTexIndexes[0] == 91)
        {
            bgScale = 1.3f;
            bgScale *= bgGlobalScaleMultiplier;
            bgParallax = 0.42;
        }
        if (bgTexIndexes[2] < 0 && WorldGen.drunkWorldGen)
        {
            return;
        }
        bgWidthScaled = (int)((float)backgroundWidth[bgTexIndexes[2]] * bgScale);
        if (bgWidthScaled == 0)
        {
            bgWidthScaled = 1;
        }
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, bgWidthScaled) - (double)(bgWidthScaled / 2));
        bgTopY = (int)(backgroundTopMagicNumber * 2100.0 + 2000.0) + (int)scAdj + pushBGTopHack;
        if (gameMenu)
        {
            bgTopY = 480 + pushBGTopHack;
            bgStartX -= 120;
        }
        if (bgTexIndexes[2] == 52)
        {
            bgTopY -= 50;
        }
        if (bgTexIndexes[2] == 55)
        {
            bgTopY -= 100;
        }
        if (bgTexIndexes[2] == 92)
        {
            bgTopY += 150;
        }
        bgLoops = screenWidth / bgWidthScaled + 2;
        if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
        {
            for (int k = 0; k < bgLoops; k++)
            {
                spriteBatch.Draw(TextureAssets.Background[bgTexIndexes[2]].Value, new Vector2(bgStartX + bgWidthScaled * k, bgTopY), GetBackgroundRect(bgTexIndexes[2]), ColorOfSurfaceBackgroundsModified, 0f, default(Vector2), bgScale, SpriteEffects.None, 0f);
            }
        }
    }
 
    private void DrawBackgroundBlackFill()
    {
        float value = (float)(worldSurface + 2.0) * 16f - screenPosition.Y;
        float value2 = (float)maxTilesY * 16f - 2880f - (screenPosition.Y + (float)screenHeight);
        value = MathHelper.Clamp(value, 0f, screenHeight);
        value2 = MathHelper.Clamp(value2, 0f, screenHeight);
        if (value2 - value > 0f)
        {
            spriteBatch.Draw(TextureAssets.BlackTile.Value, new Microsoft.Xna.Framework.Rectangle(0, (int)value, screenWidth, (int)(value2 - value)), Microsoft.Xna.Framework.Color.Black);
        }
    }
 
    public void DrawTileCracks(int crackType, HitTile hitter)
    {
        Vector2 vector = new Vector2(offScreenRange, offScreenRange);
        if (drawToScreen)
        {
            vector = Vector2.Zero;
        }
        bool flag = ShouldShowInvisibleWalls();
        for (int i = 0; i < hitter.data.Length; i++)
        {
            if (hitter.data[i].type != crackType)
            {
                continue;
            }
            int damage = hitter.data[i].damage;
            if (damage < 20)
            {
                continue;
            }
            int x = hitter.data[i].X;
            int y = hitter.data[i].Y;
            if (!WorldGen.InWorld(x, y))
            {
                continue;
            }
            bool flag2 = tile[x, y] != null;
            if (flag2 && crackType == 1)
            {
                flag2 = flag2 && tile[x, y].active() && (flag || !tile[x, y].invisibleBlock());
            }
            if (flag2 && crackType == 2)
            {
                flag2 = flag2 && tile[x, y].wall != 0 && (flag || !tile[x, y].invisibleWall());
            }
            if (!flag2)
            {
                continue;
            }
            bool flag3 = false;
            bool flag4 = false;
            if (tile[x, y].type == 10)
            {
                flag3 = false;
            }
            else if (tileSolid[tile[x, y].type] && !tileSolidTop[tile[x, y].type])
            {
                flag3 = true;
            }
            else if (WorldGen.IsTreeType(tile[x, y].type))
            {
                flag4 = true;
                int num = tile[x, y].frameX / 22;
                int num2 = tile[x, y].frameY / 22;
                if (num2 < 9)
                {
                    flag3 = ((num != 1 && num != 2) || num2 < 6 || num2 > 8) && (num != 3 || num2 > 2) && (num != 4 || num2 < 3 || num2 > 5) && ((num != 5 || num2 < 6 || num2 > 8) ? true : false);
                }
            }
            else if (tile[x, y].type == 72)
            {
                flag4 = true;
                if (tile[x, y].frameX <= 34)
                {
                    flag3 = true;
                }
            }
            if (flag3 && tile[x, y].slope() == 0 && !tile[x, y].halfBrick())
            {
                int num3 = 0;
                if (damage >= 80)
                {
                    num3 = 3;
                }
                else if (damage >= 60)
                {
                    num3 = 2;
                }
                else if (damage >= 40)
                {
                    num3 = 1;
                }
                else if (damage >= 20)
                {
                    num3 = 0;
                }
                Microsoft.Xna.Framework.Rectangle value = new Microsoft.Xna.Framework.Rectangle(hitter.data[i].crackStyle * 18, num3 * 18, 16, 16);
                if (flag4)
                {
                    value.X = (4 + hitter.data[i].crackStyle / 2) * 18;
                }
                spriteBatch.Draw(TextureAssets.TileCrack.Value, new Vector2(x * 16 - (int)screenPosition.X, y * 16 - (int)screenPosition.Y) + vector, value, Lighting.GetColor(x, y), 0f, default(Vector2), 1f, SpriteEffects.None, 0f);
            }
        }
    }
 
    private static void CheckMonoliths()
    {
        if (dedServ)
        {
            return;
        }
        bool flag = player[myPlayer].ZoneTowerVortex || player[myPlayer].ZoneTowerNebula || player[myPlayer].ZoneTowerStardust || player[myPlayer].ZoneTowerSolar;
        bool stardustMonolithShader = player[myPlayer].stardustMonolithShader;
        bool nebulaMonolithShader = player[myPlayer].nebulaMonolithShader;
        bool vortexMonolithShader = player[myPlayer].vortexMonolithShader;
        bool solarMonolithShader = player[myPlayer].solarMonolithShader;
        bool moonLordMonolithShader = player[myPlayer].moonLordMonolithShader;
        for (int i = 0; i < MonolithFilterNames.Length; i++)
        {
            bool flag2 = !flag && i == SceneMetrics.ActiveMonolithType;
            if ((i == 0 && vortexMonolithShader) || (i == 1 && nebulaMonolithShader) || (i == 2 && stardustMonolithShader) || (i == 3 && solarMonolithShader) || (i == 4 && moonLordMonolithShader))
            {
                flag2 = true;
            }
            if (flag2)
            {
                if (!Terraria.Graphics.Effects.Filters.Scene[MonolithFilterNames[i]].IsActive())
                {
                    Terraria.Graphics.Effects.Filters.Scene.Activate(MonolithFilterNames[i], default(Vector2));
                }
                if (!SkyManager.Instance[MonolithSkyNames[i]].IsActive())
                {
                    SkyManager.Instance.Activate(MonolithSkyNames[i], default(Vector2));
                }
            }
            else
            {
                if (Terraria.Graphics.Effects.Filters.Scene[MonolithFilterNames[i]].IsActive())
                {
                    Terraria.Graphics.Effects.Filters.Scene.Deactivate(MonolithFilterNames[i]);
                }
                if (SkyManager.Instance[MonolithSkyNames[i]].IsActive())
                {
                    SkyManager.Instance.Deactivate(MonolithSkyNames[i]);
                }
            }
        }
    }
 
    private void GraphicsDeviceLost(object sender, EventArgs evt)
    {
    }
 
    protected override void Draw(GameTime gameTime)
    {
        if (!_isDrawingOrUpdating && IsGraphicsDeviceAvailable)
        {
            _isDrawingOrUpdating = true;
            EnsureRenderTargetContent();
            DoDraw(gameTime);
            if (Main.OnPostDraw != null)
            {
                Main.OnPostDraw(gameTime);
            }
            Assets.TransferCompletedAssets();
            _isDrawingOrUpdating = false;
        }
    }
 
    private void DoDraw(GameTime gameTime)
    {
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        if (showSplash)
        {
            DrawSplash(gameTime);
            TimeLogger.SplashDrawTime(stopwatch.Elapsed.TotalMilliseconds);
            TimeLogger.EndDrawFrame();
            return;
        }
        if (_drawCycleCounter == 0L)
        {
            TileFrameSeed = Utils.RandomNextSeed(TileFrameSeed);
        }
        _drawCycleCounter = (_drawCycleCounter + 1) % 5;
        MenuUI.IsVisible = gameMenu && menuMode == 888;
        InGameUI.IsVisible = !gameMenu && InGameUI.CurrentState != null;
        PlayerInput.UpdateMainMouse();
        RefreshPlayerDrawOrder();
        CaptureManager.Instance.DrawTick();
        TimeLogger.NewDrawFrame();
        if (!gameMenu)
        {
            TilesRenderer.PreparePaintForTilesOnScreen();
        }
        for (int i = 0; i < ContentThatNeedsRenderTargets.Count; i++)
        {
            ContentThatNeedsRenderTargets[i].PrepareRenderTarget(base.GraphicsDevice, spriteBatch);
        }
        TilePaintSystem.PrepareAllRequests();
        TimeLogger.DetailedDrawTime(0);
        if (loadMap)
        {
            refreshMap = false;
            DrawToMap();
            TimeLogger.DetailedDrawTime(1);
        }
        if (Lighting.UpdateEveryFrame)
        {
            drawToScreen = true;
        }
        else
        {
            drawToScreen = false;
        }
        if (drawToScreen && targetSet)
        {
            ReleaseTargets();
        }
        if (!drawToScreen && !targetSet)
        {
            InitTargets();
        }
        fpsCount++;
        if (!base.IsActive)
        {
            maxQ = true;
        }
        if (!dedServ)
        {
            UpdateDisplaySettings();
            if (Main.OnPreDraw != null)
            {
                Main.OnPreDraw(gameTime);
            }
        }
        drawsCountedForFPS++;
        screenLastPosition = screenPosition;
        if (stackSplit == 0)
        {
            timesTriedToFastStack = 0;
            stackCounter = 0;
            stackDelay = 7;
            superFastStack = 0;
        }
        else
        {
            stackCounter++;
            int num = 30;
            num = ((stackDelay == 7) ? 30 : ((stackDelay == 6) ? 25 : ((stackDelay == 5) ? 20 : ((stackDelay == 4) ? 15 : ((stackDelay != 3) ? 5 : 10)))));
            if (stackCounter >= num)
            {
                stackDelay--;
                if (stackDelay < 2)
                {
                    stackDelay = 2;
                    superFastStack++;
                }
                if (timesTriedToFastStack < 10)
                {
                    superFastStack = 0;
                }
                timesTriedToFastStack++;
                stackCounter = 0;
            }
        }
        if (myPlayer >= 0)
        {
            player[myPlayer].lastMouseInterface = player[myPlayer].mouseInterface;
            player[myPlayer].mouseInterface = false;
        }
        if (mapTime > 0)
        {
            mapTime--;
        }
        if (gameMenu)
        {
            mapTime = mapTimeMax;
        }
        HoverItem = new Item();
        DoDraw_UpdateCameraPosition();
        CheckMonoliths();
        sunCircle += 0.01f;
        if ((double)sunCircle > 6.285)
        {
            sunCircle -= 6.285f;
        }
        TimeLogger.DetailedDrawReset();
        if (!gameMenu)
        {
            waterfallManager.FindWaterfalls();
            TimeLogger.DetailedDrawTime(2);
            if (renderNow)
            {
                screenLastPosition = screenPosition;
                renderNow = false;
                renderCount = 99;
                Draw(gameTime);
                Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
                Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
                RenderTiles();
                sceneTilePos.X = screenPosition.X - (float)offScreenRange;
                sceneTilePos.Y = screenPosition.Y - (float)offScreenRange;
                RenderBackground();
                sceneBackgroundPos.X = screenPosition.X - (float)offScreenRange;
                sceneBackgroundPos.Y = screenPosition.Y - (float)offScreenRange;
                RenderWalls();
                sceneWallPos.X = screenPosition.X - (float)offScreenRange;
                sceneWallPos.Y = screenPosition.Y - (float)offScreenRange;
                RenderTiles2();
                sceneTile2Pos.X = screenPosition.X - (float)offScreenRange;
                sceneTile2Pos.Y = screenPosition.Y - (float)offScreenRange;
                RenderWater();
                sceneWaterPos.X = screenPosition.X - (float)offScreenRange;
                sceneWaterPos.Y = screenPosition.Y - (float)offScreenRange;
                renderCount = 99;
            }
            else
            {
                if (renderCount == 3)
                {
                    RenderTiles();
                    sceneTilePos.X = screenPosition.X - (float)offScreenRange;
                    sceneTilePos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (renderCount == 3)
                {
                    RenderTiles2();
                    sceneTile2Pos.X = screenPosition.X - (float)offScreenRange;
                    sceneTile2Pos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (renderCount == 3)
                {
                    RenderWalls();
                    sceneWallPos.X = screenPosition.X - (float)offScreenRange;
                    sceneWallPos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (renderCount == 2)
                {
                    RenderBackground();
                    sceneBackgroundPos.X = screenPosition.X - (float)offScreenRange;
                    sceneBackgroundPos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (renderCount == 1)
                {
                    RenderWater();
                    sceneWaterPos.X = screenPosition.X - (float)offScreenRange;
                    sceneWaterPos.Y = screenPosition.Y - (float)offScreenRange;
                }
            }
            if (render && !gameMenu)
            {
                if (Math.Abs(sceneTilePos.X - (screenPosition.X - (float)offScreenRange)) > (float)offScreenRange || Math.Abs(sceneTilePos.Y - (screenPosition.Y - (float)offScreenRange)) > (float)offScreenRange)
                {
                    RenderTiles();
                    sceneTilePos.X = screenPosition.X - (float)offScreenRange;
                    sceneTilePos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (Math.Abs(sceneTile2Pos.X - (screenPosition.X - (float)offScreenRange)) > (float)offScreenRange || Math.Abs(sceneTile2Pos.Y - (screenPosition.Y - (float)offScreenRange)) > (float)offScreenRange)
                {
                    RenderTiles2();
                    sceneTile2Pos.X = screenPosition.X - (float)offScreenRange;
                    sceneTile2Pos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (Math.Abs(sceneBackgroundPos.X - (screenPosition.X - (float)offScreenRange)) > (float)offScreenRange || Math.Abs(sceneBackgroundPos.Y - (screenPosition.Y - (float)offScreenRange)) > (float)offScreenRange)
                {
                    RenderBackground();
                    sceneBackgroundPos.X = screenPosition.X - (float)offScreenRange;
                    sceneBackgroundPos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (Math.Abs(sceneWallPos.X - (screenPosition.X - (float)offScreenRange)) > (float)offScreenRange || Math.Abs(sceneWallPos.Y - (screenPosition.Y - (float)offScreenRange)) > (float)offScreenRange)
                {
                    RenderWalls();
                    sceneWallPos.X = screenPosition.X - (float)offScreenRange;
                    sceneWallPos.Y = screenPosition.Y - (float)offScreenRange;
                }
                if (Math.Abs(sceneWaterPos.X - (screenPosition.X - (float)offScreenRange)) > (float)offScreenRange || Math.Abs(sceneWaterPos.Y - (screenPosition.Y - (float)offScreenRange)) > (float)offScreenRange)
                {
                    RenderWater();
                    sceneWaterPos.X = screenPosition.X - (float)offScreenRange;
                    sceneWaterPos.Y = screenPosition.Y - (float)offScreenRange;
                }
            }
        }
        if (!loadMap)
        {
            if (!gameMenu)
            {
                TimeLogger.DetailedDrawReset();
                Stopwatch stopwatch2 = new Stopwatch();
                stopwatch2.Start();
                int num2 = 0;
                int x;
                int y;
                while (stopwatch2.ElapsedMilliseconds < 5 && sectionManager.GetNextMapDraw(player[myPlayer].position, out x, out y))
                {
                    DrawToMap_Section(x, y);
                    num2++;
                }
                TimeLogger.DetailedDrawTime(3);
            }
            if (updateMap)
            {
                if (base.IsActive || netMode == 1)
                {
                    if (refreshMap)
                    {
                        refreshMap = false;
                        sectionManager.ClearMapDraw();
                    }
                    DrawToMap();
                    updateMap = false;
                }
                else if (MapHelper.numUpdateTile > 0)
                {
                    DrawToMap();
                }
                TimeLogger.DetailedDrawTime(4);
            }
        }
        bgParallax = 0.1;
        bgStartX = (int)(0.0 - Math.IEEERemainder((double)screenPosition.X * bgParallax, backgroundWidth[background]) - (double)(backgroundWidth[background] / 2));
        bgLoops = screenWidth / backgroundWidth[background] + 2;
        bgStartY = 0;
        bgLoopsY = 0;
        bgTopY = (int)((double)(0f - screenPosition.Y) / (worldSurface * 16.0 - 600.0) * 200.0);
        if (gameMenu || netMode == 2)
        {
            bgTopY = -200;
        }
        int num3 = dayRate;
        if (num3 < 1)
        {
            num3 = 1;
        }
        float num4 = 0.0005f * (float)num3;
        if (gameMenu)
        {
            num4 *= 20f;
        }
        if (raining)
        {
            if (cloudAlpha > maxRaining)
            {
                cloudAlpha -= num4;
                if (cloudAlpha < maxRaining)
                {
                    cloudAlpha = maxRaining;
                }
            }
            else if (cloudAlpha < maxRaining)
            {
                cloudAlpha += num4;
                if (cloudAlpha > maxRaining)
                {
                    cloudAlpha = maxRaining;
                }
            }
        }
        else
        {
            cloudAlpha -= num4;
            if (cloudAlpha < 0f)
            {
                cloudAlpha = 0f;
            }
        }
        if (gameMenu || netMode == 2)
        {
            bgDelay = 1000;
            SceneMetrics.EvilTileCount = (int)(bgAlphaFrontLayer[1] * (float)SceneMetrics.CorruptionTileMax);
        }
        Microsoft.Xna.Framework.Color moonColor = Microsoft.Xna.Framework.Color.White;
        Microsoft.Xna.Framework.Color sunColor = Microsoft.Xna.Framework.Color.White;
        float num5 = SceneMetrics.MushroomTileCount / SceneMetrics.MushroomTileMax;
        float num6 = SmoothedMushroomLightInfluence;
        if (num5 > 0f)
        {
            if (num5 > num6)
            {
                num6 += 0.01f;
            }
            if (num5 < num6)
            {
                num6 -= 0.01f;
            }
        }
        else
        {
            num6 -= 0.02f;
        }
        if (num6 < 0f)
        {
            num6 = 0f;
        }
        if (num6 > 1f)
        {
            num6 = 1f;
        }
        SmoothedMushroomLightInfluence = num6;
        InfoToSetBackColor info = default(InfoToSetBackColor);
        info.isInGameMenuOrIsServer = gameMenu || netMode == 2;
        info.CorruptionBiomeInfluence = (float)SceneMetrics.EvilTileCount / (float)SceneMetrics.CorruptionTileMax;
        info.CrimsonBiomeInfluence = (float)SceneMetrics.BloodTileCount / (float)SceneMetrics.CrimsonTileMax;
        info.JungleBiomeInfluence = (float)SceneMetrics.JungleTileCount / (float)SceneMetrics.JungleTileMax;
        info.MushroomBiomeInfluence = SmoothedMushroomLightInfluence;
        info.GraveyardInfluence = GraveyardVisualIntensity;
        info.BloodMoonActive = bloodMoon || SceneMetrics.BloodMoonMonolith;
        info.LanternNightActive = LanternNight.LanternsUp;
        SetBackColor(info, out sunColor, out moonColor);
        if (gameMenu || netMode == 2)
        {
            bgTopY = 0;
        }
        ApplyColorOfTheSkiesToTiles();
        UpdateAtmosphereTransparencyToSkyColor();
        base.GraphicsDevice.Clear(Microsoft.Xna.Framework.Color.Black);
        base.Draw(gameTime);
        float val = (float)screenWidth / MinimumZoomComparerX;
        float val2 = (float)screenHeight / MinimumZoomComparerY;
        ForcedMinimumZoom = Math.Max(Math.Max(1f, val), val2);
        GameViewMatrix.Effects = ((!gameMenu && player[myPlayer].gravDir != 1f) ? SpriteEffects.FlipVertically : SpriteEffects.None);
        BackgroundViewMatrix.Effects = GameViewMatrix.Effects;
        BackgroundViewMatrix.Zoom = new Vector2(ForcedMinimumZoom);
        GameViewMatrix.Zoom = new Vector2(ForcedMinimumZoom * MathHelper.Clamp(GameZoomTarget, 1f, 2f));
        if (gameMenu || player[myPlayer].gravDir == 1f)
        {
            Rasterizer = RasterizerState.CullCounterClockwise;
        }
        else
        {
            Rasterizer = RasterizerState.CullClockwise;
        }
        bool flag = gameMenu;
        if (dontStarveWorld && WorldGen.generatingWorld)
        {
            if (!Terraria.Graphics.Effects.Filters.Scene["Sepia"].IsActive())
            {
                Terraria.Graphics.Effects.Filters.Scene.Activate("Sepia", default(Vector2));
            }
            flag = false;
        }
        else if (flag && Terraria.Graphics.Effects.Filters.Scene["Sepia"].IsActive())
        {
            Terraria.Graphics.Effects.Filters.Scene.Deactivate("Sepia");
        }
        if (Terraria.Graphics.Effects.Filters.Scene["Sepia"].IsInUse())
        {
            flag = false;
        }
        bool flag2 = !(drawToScreen || netMode == 2 || flag) && !mapFullscreen && Lighting.NotRetro && Terraria.Graphics.Effects.Filters.Scene.CanCapture();
        if (flag2)
        {
            Terraria.Graphics.Effects.Filters.Scene.BeginCapture(screenTarget, Microsoft.Xna.Framework.Color.Black);
        }
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, BackgroundViewMatrix.TransformationMatrix);
        TimeLogger.DetailedDrawReset();
        SceneArea sceneArea = default(SceneArea);
        sceneArea.bgTopY = bgTopY;
        sceneArea.totalHeight = screenHeight;
        sceneArea.totalWidth = screenWidth;
        sceneArea.SceneLocalScreenPositionOffset = Vector2.Zero;
        SceneArea sceneArea2 = sceneArea;
        if (!mapFullscreen)
        {
            unityMouseOver = false;
            if ((double)screenPosition.Y < worldSurface * 16.0 + 16.0)
            {
                Asset<Texture2D> val3 = TextureAssets.Background[background];
                Microsoft.Xna.Framework.Rectangle destinationRectangle = new Microsoft.Xna.Framework.Rectangle(bgStartX, bgTopY, val3.Width(), Math.Max(screenHeight, val3.Height()));
                if (destinationRectangle.Bottom < val3.Height())
                {
                    int num7 = val3.Height() - destinationRectangle.Bottom;
                    destinationRectangle.Height += num7;
                }
                if (false)
                {
                    for (int j = 0; j < bgLoops; j++)
                    {
                        destinationRectangle.X = bgStartX + val3.Width() * j;
                        spriteBatch.Draw(val3.Value, destinationRectangle, null, ColorOfTheSkies, 0f, Vector2.Zero, SpriteEffects.FlipVertically, 0f);
                    }
                }
                else
                {
                    for (int k = 0; k < bgLoops; k++)
                    {
                        destinationRectangle.X = bgStartX + val3.Width() * k;
                        spriteBatch.Draw(val3.Value, destinationRectangle, ColorOfTheSkies);
                    }
                }
                TimeLogger.DetailedDrawTime(6);
            }
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, BackgroundViewMatrix.EffectMatrix);
            if (shimmerAlpha != 1f)
            {
                DrawStarsInBackground(sceneArea2, artificial: false);
            }
            if ((double)(screenPosition.Y / 16f) < worldSurface + 2.0)
            {
                DrawSunAndMoon(sceneArea2, moonColor, sunColor, num6);
            }
            TimeLogger.DetailedDrawTime(7);
        }
        Overlays.Scene.Draw(spriteBatch, RenderLayers.Sky);
        spriteBatch.End();
        Vector2 vector = screenPosition;
        int num8 = screenWidth;
        int num9 = screenHeight;
        screenWidth = (int)((float)screenWidth / BackgroundViewMatrix.Zoom.X);
        screenHeight = (int)((float)screenHeight / BackgroundViewMatrix.Zoom.Y);
        screenPosition += BackgroundViewMatrix.Translation;
        Matrix transformationMatrix = BackgroundViewMatrix.TransformationMatrix;
        transformationMatrix.Translation -= BackgroundViewMatrix.ZoomMatrix.Translation * new Vector3(1f, BackgroundViewMatrix.Effects.HasFlag(SpriteEffects.FlipVertically) ? (-1f) : 1f, 1f);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, Rasterizer, null, transformationMatrix);
        CurrentFrameFlags.Hacks.CurrentBackgroundMatrixForCreditsRoll = transformationMatrix;
        DrawBG();
        screenWidth = num8;
        screenHeight = num9;
        screenPosition = vector;
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, Rasterizer, null, GameViewMatrix.TransformationMatrix);
        DrawBackgroundBlackFill();
        spriteBatch.End();
        Overlays.Scene.Draw(spriteBatch, RenderLayers.Landscape);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, Rasterizer, null, UIScaleMatrix);
        if (gameMenu || netMode == 2)
        {
            spriteBatch.End();
            PreDrawMenu(out var screenSizeCache, out var screenSizeCacheAfterScaling);
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, Rasterizer, null, UIScaleMatrix);
            DrawMenu(gameTime);
            PostDrawMenu(screenSizeCache, screenSizeCacheAfterScaling);
            TimeLogger.MenuDrawTime(stopwatch.Elapsed.TotalMilliseconds);
            TimeLogger.EndDrawFrame();
            if (flag2)
            {
                Terraria.Graphics.Effects.Filters.Scene.EndCapture(null, screenTarget, screenTargetSwap, Microsoft.Xna.Framework.Color.Black);
            }
            return;
        }
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        DoLightTiles();
        TimeLogger.DetailedDrawReset();
        if (mapFullscreen)
        {
            if (player[myPlayer].talkNPC >= 0 || player[myPlayer].sign >= 0 || (playerInventory && !CaptureManager.Instance.Active))
            {
                player[myPlayer].ToggleInv();
            }
            DrawMap(gameTime);
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, SamplerStateForCursor, null, null, null, UIScaleMatrix);
            PlayerInput.SetZoom_UI();
            DrawFPS();
            DrawPlayerChat();
            DrawPendingMouseText();
            DrawCursor(DrawThickCursor());
            PlayerInput.SetZoom_Unscaled();
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null);
            TimeLogger.MapDrawTime(stopwatch.Elapsed.TotalMilliseconds);
            TimeLogger.EndDrawFrame();
            PlayerInput.SetDesiredZoomContext(ZoomContext.Unscaled);
            CaptureManager.Instance.Update();
            if (CaptureManager.Instance.Active)
            {
                CaptureManager.Instance.Draw(spriteBatch);
            }
            spriteBatch.End();
            if (mouseLeft)
            {
                mouseLeftRelease = false;
            }
            else
            {
                mouseLeftRelease = true;
            }
            return;
        }
        if (shimmerAlpha > 0f)
        {
            spriteBatch.Draw(TextureAssets.MagicPixel.Value, Vector2.Zero, null, Microsoft.Xna.Framework.Color.Black * shimmerAlpha, 0f, Vector2.Zero, new Vector2(Camera.UnscaledSize.X + (float)(offScreenRange * 2), Camera.UnscaledSize.Y + (float)(offScreenRange * 2)), SpriteEffects.None, 0f);
        }
        Overlays.Scene.Draw(spriteBatch, RenderLayers.InWorldUI);
        _ = Microsoft.Xna.Framework.Color.White;
        if (drawToScreen)
        {
            DrawWaters(isBackground: true);
        }
        else
        {
            spriteBatch.Draw(backWaterTarget, sceneBackgroundPos - screenPosition, Microsoft.Xna.Framework.Color.White);
            TimeLogger.DetailedDrawTime(11);
        }
        Overlays.Scene.Draw(spriteBatch, RenderLayers.BackgroundWater);
        float x2 = (sceneBackgroundPos.X - screenPosition.X + (float)offScreenRange) * caveParallax - (float)offScreenRange;
        if (shimmerAlpha > 0f)
        {
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null);
            PlayerInput.SetZoom_Unscaled();
            DrawStarsInBackground(sceneArea2, artificial: true);
            spriteBatch.End();
            PlayerInput.SetDesiredZoomContext(ZoomContext.World);
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        }
        if (drawToScreen)
        {
            tileBatch.Begin();
            DrawBackground();
            tileBatch.End();
        }
        else
        {
            spriteBatch.Draw(backgroundTarget, new Vector2(x2, sceneBackgroundPos.Y - screenPosition.Y), Microsoft.Xna.Framework.Color.White);
            TimeLogger.DetailedDrawTime(12);
        }
        Overlays.Scene.Draw(spriteBatch, RenderLayers.Background);
        ScreenDarkness.DrawBack(spriteBatch);
        magmaBGFrameCounter++;
        if (magmaBGFrameCounter >= 8)
        {
            magmaBGFrameCounter = 0;
            magmaBGFrame++;
            if (magmaBGFrame >= 3)
            {
                magmaBGFrame = 0;
            }
        }
        DoDraw_WallsTilesNPCs();
        Overlays.Scene.Draw(spriteBatch, RenderLayers.TilesAndNPCs);
        if (!mapFullscreen && mapStyle == 2)
        {
            try
            {
                DrawMap(gameTime);
            }
            catch (Exception e)
            {
                if (!ignoreErrors)
                {
                    throw;
                }
                TimeLogger.DrawException(e);
            }
        }
        TimeLogger.DetailedDrawReset();
        spriteBatch.End();
        TimeLogger.DetailedDrawTime(35);
        HasInteractibleObjectThatIsNotATile = false;
        SortDrawCacheWorms();
        DrawSuperSpecialProjectiles(DrawCacheFirstFractals);
        DrawCachedProjs(DrawCacheProjsBehindProjectiles);
        DrawProjectiles();
        spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        ParticleSystem_World_BehindPlayers.Settings.AnchorPosition = -screenPosition;
        ParticleSystem_World_BehindPlayers.Draw(spriteBatch);
        spriteBatch.End();
        DrawPlayers_AfterProjectiles();
        DrawCachedProjs(DrawCacheProjsOverPlayers);
        spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        ParticleSystem_World_OverPlayers.Settings.AnchorPosition = -screenPosition;
        ParticleSystem_World_OverPlayers.Draw(spriteBatch);
        spriteBatch.End();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        DrawCachedNPCs(DrawCacheNPCsOverPlayers, behindTiles: false);
        if (!gamePaused)
        {
            essScale += (float)essDir * 0.01f;
            if (essScale > 1f)
            {
                essDir = -1;
                essScale = 1f;
            }
            if ((double)essScale < 0.7)
            {
                essDir = 1;
                essScale = 0.7f;
            }
        }
        DrawItems();
        TimeLogger.DetailedDrawTime(22);
        DrawRain();
        if (ignoreErrors)
        {
            try
            {
                DrawGore();
            }
            catch (Exception e2)
            {
                TimeLogger.DrawException(e2);
            }
        }
        else
        {
            DrawGore();
        }
        spriteBatch.End();
        DrawDust();
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        Overlays.Scene.Draw(spriteBatch, RenderLayers.Entities);
        if (drawToScreen)
        {
            DrawWaters();
            if (WiresUI.Settings.DrawWires)
            {
                DrawWires();
            }
        }
        else
        {
            spriteBatch.Draw(waterTarget, sceneWaterPos - screenPosition, Microsoft.Xna.Framework.Color.White);
            if (WiresUI.Settings.DrawWires)
            {
                DrawWires();
            }
            TimeLogger.DetailedDrawTime(26);
        }
        if (shimmerAlpha > 0f)
        {
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null, BackgroundViewMatrix.EffectMatrix);
            PlayerInput.SetZoom_Unscaled();
            DrawStarsInForeground(sceneArea2);
            spriteBatch.End();
            PlayerInput.SetDesiredZoomContext(ZoomContext.World);
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        }
        Overlays.Scene.Draw(spriteBatch, RenderLayers.ForegroundWater);
        DrawCachedProjs(DrawCacheProjsOverWiresUI, startSpriteBatch: false);
        DrawInfernoRings();
        ScreenDarkness.DrawFront(spriteBatch);
        MoonlordDeathDrama.DrawWhite(spriteBatch);
        ScreenObstruction.Draw(spriteBatch);
        TimeLogger.DetailedDrawReset();
        spriteBatch.End();
        Overlays.Scene.Draw(spriteBatch, RenderLayers.All);
        if (flag2)
        {
            Terraria.Graphics.Effects.Filters.Scene.EndCapture(null, screenTarget, screenTargetSwap, Microsoft.Xna.Framework.Color.Black);
        }
        TimeLogger.DetailedDrawTime(36);
        if (!hideUI)
        {
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null, UIScaleMatrix);
            TimeLogger.DetailedDrawReset();
            DrawPlayerChatBubbles();
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null, GameViewMatrix.ZoomMatrix);
            float targetScale = CombatText.TargetScale;
            for (int l = 0; l < 100; l++)
            {
                if (!combatText[l].active)
                {
                    continue;
                }
                int num10 = 0;
                if (combatText[l].crit)
                {
                    num10 = 1;
                }
                Vector2 vector2 = FontAssets.CombatText[num10].Value.MeasureString(combatText[l].text);
                Vector2 vector3 = new Vector2(vector2.X * 0.5f, vector2.Y * 0.5f);
                float num11 = combatText[l].scale / targetScale;
                float num12 = (int)combatText[l].color.R;
                float num13 = (int)combatText[l].color.G;
                float num14 = (int)combatText[l].color.B;
                float num15 = (int)combatText[l].color.A;
                num12 *= num11 * combatText[l].alpha * 0.3f;
                num14 *= num11 * combatText[l].alpha * 0.3f;
                num13 *= num11 * combatText[l].alpha * 0.3f;
                num15 *= num11 * combatText[l].alpha;
                Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color((int)num12, (int)num13, (int)num14, (int)num15);
                for (int m = 0; m < 5; m++)
                {
                    float num16 = 0f;
                    float num17 = 0f;
                    switch (m)
                    {
                    case 0:
                        num16 -= targetScale;
                        break;
                    case 1:
                        num16 += targetScale;
                        break;
                    case 2:
                        num17 -= targetScale;
                        break;
                    case 3:
                        num17 += targetScale;
                        break;
                    default:
                        num12 = (float)(int)combatText[l].color.R * num11 * combatText[l].alpha;
                        num14 = (float)(int)combatText[l].color.B * num11 * combatText[l].alpha;
                        num13 = (float)(int)combatText[l].color.G * num11 * combatText[l].alpha;
                        num15 = (float)(int)combatText[l].color.A * num11 * combatText[l].alpha;
                        color = new Microsoft.Xna.Framework.Color((int)num12, (int)num13, (int)num14, (int)num15);
                        break;
                    }
                    if (player[myPlayer].gravDir == -1f)
                    {
                        float num18 = combatText[l].position.Y - screenPosition.Y;
                        num18 = (float)screenHeight - num18;
                        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.CombatText[num10].Value, combatText[l].text, new Vector2(combatText[l].position.X - screenPosition.X + num16 + vector3.X, num18 + num17 + vector3.Y), color, combatText[l].rotation, vector3, combatText[l].scale, SpriteEffects.None, 0f);
                    }
                    else
                    {
                        DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.CombatText[num10].Value, combatText[l].text, new Vector2(combatText[l].position.X - screenPosition.X + num16 + vector3.X, combatText[l].position.Y - screenPosition.Y + num17 + vector3.Y), color, combatText[l].rotation, vector3, combatText[l].scale, SpriteEffects.None, 0f);
                    }
                }
            }
            targetScale = PopupText.TargetScale;
            if (targetScale == 0f)
            {
                targetScale = 1f;
            }
            DrawItemTextPopups(targetScale);
            PlayerInput.SetZoom_UI();
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null, UIScaleMatrix);
            DrawNetplayStatusText();
            DrawFPS();
            spriteBatch.End();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, null, null, null, GameViewMatrix.ZoomMatrix);
            PlayerInput.SetZoom_World();
            if (BlackFadeIn > 0)
            {
                if (BlackFadeIn < 0)
                {
                    BlackFadeIn = 0;
                }
                int num19 = BlackFadeIn;
                if (num19 > 255)
                {
                    num19 = 255;
                }
                BlackFadeIn -= 25;
                spriteBatch.Draw(TextureAssets.SplashTexture16x9.Value, new Microsoft.Xna.Framework.Rectangle(0, 0, screenWidth, screenHeight), new Microsoft.Xna.Framework.Color(0, 0, 0, num19));
            }
            spriteBatch.End();
            if (!mapFullscreen)
            {
                if (ignoreErrors)
                {
                    try
                    {
                        DrawInterface(gameTime);
                    }
                    catch (Exception e3)
                    {
                        TimeLogger.DrawException(e3);
                    }
                }
                else
                {
                    DrawInterface(gameTime);
                }
            }
            TimeLogger.DetailedDrawTime(27);
        }
        else
        {
            maxQ = true;
        }
        TimeLogger.DetailedDrawTime(37);
        if (mouseLeft)
        {
            mouseLeftRelease = false;
        }
        else
        {
            mouseLeftRelease = true;
        }
        if (mouseRight)
        {
            mouseRightRelease = false;
        }
        else
        {
            mouseRightRelease = true;
        }
        if (!PlayerInput.Triggers.Current.MouseRight && !PlayerInput.Triggers.Current.MouseLeft && !preventStackSplitReset)
        {
            stackSplit = 0;
        }
        if (stackSplit > 0)
        {
            stackSplit--;
            if (stackSplit == 0)
            {
                preventStackSplitReset = false;
            }
        }
        TimeLogger.RenderTime(renderCount, stopwatch.Elapsed.TotalMilliseconds);
        TimeLogger.EndDrawFrame();
    }
 
    private static void DrawItemTextPopups(float scaleTarget)
    {
        for (int i = 0; i < 20; i++)
        {
            PopupText popupText = Main.popupText[i];
            if (!popupText.active)
            {
                continue;
            }
            string text = popupText.name;
            if (popupText.stack > 1)
            {
                text = text + " (" + popupText.stack + ")";
            }
            Vector2 vector = FontAssets.MouseText.Value.MeasureString(text);
            Vector2 vector2 = new Vector2(vector.X * 0.5f, vector.Y * 0.5f);
            float num = popupText.scale / scaleTarget;
            int num2 = (int)(255f - 255f * num);
            float num3 = (int)popupText.color.R;
            float num4 = (int)popupText.color.G;
            float num5 = (int)popupText.color.B;
            float num6 = (int)popupText.color.A;
            num3 *= num * popupText.alpha * 0.3f;
            num5 *= num * popupText.alpha * 0.3f;
            num4 *= num * popupText.alpha * 0.3f;
            num6 *= num * popupText.alpha;
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color((int)num3, (int)num4, (int)num5, (int)num6);
            Microsoft.Xna.Framework.Color color2 = Microsoft.Xna.Framework.Color.Black;
            float num7 = 1f;
            Texture2D texture2D = null;
            switch (popupText.context)
            {
            case PopupTextContext.ItemPickupToVoidContainer:
                color2 = new Microsoft.Xna.Framework.Color(127, 20, 255) * 0.4f;
                num7 = 0.8f;
                break;
            case PopupTextContext.SonarAlert:
                color2 = Microsoft.Xna.Framework.Color.Blue * 0.4f;
                if (popupText.npcNetID != 0)
                {
                    color2 = Microsoft.Xna.Framework.Color.Red * 0.4f;
                }
                num7 = 1f;
                break;
            }
            float num8 = (float)num2 / 255f;
            for (int j = 0; j < 5; j++)
            {
                color = color2;
                float num9 = 0f;
                float num10 = 0f;
                switch (j)
                {
                case 0:
                    num9 -= scaleTarget * 2f;
                    break;
                case 1:
                    num9 += scaleTarget * 2f;
                    break;
                case 2:
                    num10 -= scaleTarget * 2f;
                    break;
                case 3:
                    num10 += scaleTarget * 2f;
                    break;
                default:
                    color = popupText.color * num * popupText.alpha * num7;
                    break;
                }
                if (j < 4)
                {
                    num6 = (float)(int)popupText.color.A * num * popupText.alpha;
                    color = new Microsoft.Xna.Framework.Color(0, 0, 0, (int)num6);
                }
                if (color2 != Microsoft.Xna.Framework.Color.Black && j < 4)
                {
                    num9 *= 1.3f + 1.3f * num8;
                    num10 *= 1.3f + 1.3f * num8;
                }
                float num11 = popupText.position.Y - screenPosition.Y + num10;
                if (player[myPlayer].gravDir == -1f)
                {
                    num11 = (float)screenHeight - num11;
                }
                if (color2 != Microsoft.Xna.Framework.Color.Black && j < 4)
                {
                    Microsoft.Xna.Framework.Color color3 = color2;
                    color3.A = (byte)MathHelper.Lerp(60f, 127f, Utils.GetLerpValue(0f, 255f, num6, clamped: true));
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(popupText.position.X - screenPosition.X + num9 + vector2.X, num11 + vector2.Y), Microsoft.Xna.Framework.Color.Lerp(color, color3, 0.5f), popupText.rotation, vector2, popupText.scale, SpriteEffects.None, 0f);
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(popupText.position.X - screenPosition.X + num9 + vector2.X, num11 + vector2.Y), color3, popupText.rotation, vector2, popupText.scale, SpriteEffects.None, 0f);
                }
                else
                {
                    DynamicSpriteFontExtensionMethods.DrawString(spriteBatch, FontAssets.MouseText.Value, text, new Vector2(popupText.position.X - screenPosition.X + num9 + vector2.X, num11 + vector2.Y), color, popupText.rotation, vector2, popupText.scale, SpriteEffects.None, 0f);
                }
                if (texture2D != null)
                {
                    float scale = (1.3f - num8) * popupText.scale * 0.7f;
                    Vector2 vector3 = new Vector2(popupText.position.X - screenPosition.X + num9 + vector2.X, num11 + vector2.Y);
                    Microsoft.Xna.Framework.Color color4 = color2 * 0.6f;
                    if (j == 4)
                    {
                        color4 = Microsoft.Xna.Framework.Color.White * 0.6f;
                    }
                    color4.A = (byte)((float)(int)color4.A * 0.5f);
                    int num12 = 25;
                    spriteBatch.Draw(texture2D, vector3 + new Vector2(vector2.X * -0.5f - (float)num12 - texture2D.Size().X / 2f, 0f), null, color4 * popupText.scale, 0f, texture2D.Size() / 2f, scale, SpriteEffects.None, 0f);
                    spriteBatch.Draw(texture2D, vector3 + new Vector2(vector2.X * 0.5f + (float)num12 + texture2D.Size().X / 2f, 0f), null, color4 * popupText.scale, 0f, texture2D.Size() / 2f, scale, SpriteEffects.None, 0f);
                }
            }
        }
    }
 
    private static void DoDraw_UpdateCameraPosition()
    {
        Vector3 vector = new Vector3(1f, 1f, 1f);
        Vector3 vector2 = Vector3.One / vector;
        if (gameMenu || netMode == 2)
        {
            return;
        }
        int num = 21;
        if (cameraX != 0f && !Main.player[myPlayer].pulley)
        {
            cameraX = 0f;
        }
        if (cameraX > 0f)
        {
            cameraX -= 1f;
            if (cameraX < 0f)
            {
                cameraX = 0f;
            }
        }
        if (cameraX < 0f)
        {
            cameraX += 1f;
            if (cameraX > 0f)
            {
                cameraX = 0f;
            }
        }
        Vector2 value = screenPosition;
        screenPosition.X = Main.player[myPlayer].position.X + (float)Main.player[myPlayer].width * 0.5f - (float)screenWidth * 0.5f * vector2.X + cameraX;
        screenPosition.Y = Main.player[myPlayer].position.Y + (float)Main.player[myPlayer].height - (float)num - (float)screenHeight * 0.5f * vector2.Y + Main.player[myPlayer].gfxOffY;
        Vector2 vector3 = Vector2.Zero;
        float num2 = 0f;
        float num3 = 0f;
        float num4 = 36f;
        bool flag = false;
        Vector2 vector4 = Vector2.Zero;
        if (!Main.player[myPlayer].dead)
        {
            if (DroneCameraTracker.TryTracking(out var cameraPosition))
            {
                vector3 = cameraPosition - LocalPlayer.Center;
                if (LocalPlayer.gravDir == -1f)
                {
                    vector3.Y *= -1f;
                }
                vector4 = vector3;
                vector3 = CurrentPan * 0.87f + vector3 * 0.13f;
                flag = true;
                _cameraPanHasBlackTransition = true;
            }
            else if (LocalGolfState != null && (LocalGolfState.ShouldCameraTrackBallLastKnownLocation || LocalGolfState.IsTrackingBall))
            {
                if (LocalGolfState.IsTrackingBall)
                {
                    Projectile lastHitBall = LocalGolfState.GetLastHitBall();
                    vector3 = lastHitBall.Center - LocalPlayer.Center;
                    vector4 = vector3;
                    _cameraPanHasBlackTransition = true;
                    if (lastHitBall.velocity.Length() > 20f)
                    {
                        num4 *= 2f;
                    }
                    vector3 = CurrentPan * 0.87f + vector3 * 0.13f;
                    flag = true;
                }
                else if (LocalGolfState.ShouldCameraTrackBallLastKnownLocation)
                {
                    Vector2? lastBallLocation = LocalGolfState.GetLastBallLocation();
                    if (lastBallLocation.HasValue)
                    {
                        vector3 = lastBallLocation.Value - LocalPlayer.Center;
                        vector4 = vector3;
                        _cameraPanHasBlackTransition = true;
                        vector3 = CurrentPan * 0.87f + vector3 * 0.13f;
                        flag = true;
                    }
                }
            }
            else if ((Main.player[myPlayer].noThrow <= 0 && !Main.player[myPlayer].lastMouseInterface) || !(CurrentPan == Vector2.Zero))
            {
                if (PlayerInput.UsingGamepad)
                {
                    Player player = Main.player[myPlayer];
                    if (PlayerInput.GamepadThumbstickRight.Length() != 0f || !SmartCursorIsUsed)
                    {
                        float num5 = -1f;
                        if (player.inventory[player.selectedItem].type == 1254 && player.scope)
                        {
                            num5 = 0.8f;
                        }
                        else if (player.inventory[player.selectedItem].type == 1254)
                        {
                            num5 = 2f / 3f;
                        }
                        else if (player.inventory[player.selectedItem].type == 1299)
                        {
                            num5 = 2f / 3f;
                        }
                        else if (player.scope)
                        {
                            num5 = 0.5f;
                        }
                        Vector2 vector5 = (MouseScreen - new Vector2(screenWidth, screenHeight) / 2f) / (new Vector2(screenWidth, screenHeight) / 2f);
                        num4 = 48f;
                        if (vector5 != Vector2.Zero && num5 != -1f)
                        {
                            Vector2 vector6 = new Vector2(screenWidth, screenHeight) * 0.5f * vector5 * num5;
                            vector3.X = vector6.X;
                            vector3.Y = vector6.Y;
                            flag = true;
                        }
                    }
                }
                else if (Main.player[myPlayer].inventory[Main.player[myPlayer].selectedItem].type == 1254 && Main.player[myPlayer].scope && mouseRight)
                {
                    int num6 = mouseX;
                    int num7 = mouseY;
                    if (num6 > screenWidth)
                    {
                        num6 = screenWidth;
                    }
                    if (num6 < 0)
                    {
                        num6 = 0;
                    }
                    if (num7 > screenHeight)
                    {
                        num7 = screenHeight;
                    }
                    if (num7 < 0)
                    {
                        num7 = 0;
                    }
                    vector3.X = (float)(num6 - screenWidth / 2) / 1.25f;
                    vector3.Y = (float)(num7 - screenHeight / 2) / 1.25f;
                    flag = true;
                }
                else if (Main.player[myPlayer].inventory[Main.player[myPlayer].selectedItem].type == 1254 && mouseRight)
                {
                    int num8 = mouseX;
                    int num9 = mouseY;
                    if (num8 > screenWidth)
                    {
                        num8 = screenWidth;
                    }
                    if (num8 < 0)
                    {
                        num8 = 0;
                    }
                    if (num9 > screenHeight)
                    {
                        num9 = screenHeight;
                    }
                    if (num9 < 0)
                    {
                        num9 = 0;
                    }
                    vector3.X = (float)(num8 - screenWidth / 2) / 1.5f;
                    vector3.Y = (float)(num9 - screenHeight / 2) / 1.5f;
                    flag = true;
                }
                else if (Main.player[myPlayer].inventory[Main.player[myPlayer].selectedItem].type == 1299 && Main.player[myPlayer].selectedItem != 58)
                {
                    int num10 = mouseX;
                    int num11 = mouseY;
                    if (num10 > screenWidth)
                    {
                        num10 = screenWidth;
                    }
                    if (num10 < 0)
                    {
                        num10 = 0;
                    }
                    if (num11 > screenHeight)
                    {
                        num11 = screenHeight;
                    }
                    if (num11 < 0)
                    {
                        num11 = 0;
                    }
                    vector3.X = (float)(num10 - screenWidth / 2) / 1.5f;
                    vector3.Y = (float)(num11 - screenHeight / 2) / 1.5f;
                    flag = true;
                }
                else if (Main.player[myPlayer].scope && mouseRight)
                {
                    int num12 = mouseX;
                    int num13 = mouseY;
                    if (num12 > screenWidth)
                    {
                        num12 = screenWidth;
                    }
                    if (num12 < 0)
                    {
                        num12 = 0;
                    }
                    if (num13 > screenHeight)
                    {
                        num13 = screenHeight;
                    }
                    if (num13 < 0)
                    {
                        num13 = 0;
                    }
                    vector3.X = (float)(num12 - screenWidth / 2) / 2f;
                    vector3.Y = (float)(num13 - screenHeight / 2) / 2f;
                    flag = true;
                }
            }
        }
        if (float.IsNaN(CurrentPan.X))
        {
            CurrentPan.X = 0f;
        }
        if (float.IsNaN(CurrentPan.Y))
        {
            CurrentPan.Y = 0f;
        }
        Vector2 value2 = vector3 - CurrentPan;
        float num14 = value2.Length();
        float amount = 1f;
        if (num3 > num2 + 0.0001f)
        {
            amount = MathHelper.Clamp((num14 - num2) / (num3 - num2), 0f, 1f);
        }
        float value3 = MathHelper.SmoothStep(0f, num14, amount);
        value3 = MathHelper.Clamp(value3, 0f, num4);
        if (CurrentPan == Vector2.Zero && _cameraPanHasBlackTransition && vector4 != Vector2.Zero)
        {
            Vector2 vector7 = vector4 - CurrentPan;
            float num15 = Math.Abs(vector7.X);
            float num16 = Math.Abs(vector7.Y);
            float num17 = vector7.Length();
            if ((num15 >= (float)(screenWidth / 2) || num16 >= (float)(screenHeight / 2)) && num17 >= new Vector2(screenWidth, screenHeight).Length() / 2f + 100f)
            {
                renderNow = true;
                CurrentPan = vector4;
                _cameraPanHasBlackTransition = false;
                NPC.ResetNetOffsets();
                BlackFadeIn = 255;
                if (mapTime < 5)
                {
                    mapTime = 5;
                }
                maxQ = true;
                Lighting.Clear();
                instantBGTransitionCounter = 10;
                LocalPlayer.ForceUpdateBiomes();
            }
        }
        if (vector3 == Vector2.Zero && !flag)
        {
            float num18 = Math.Abs(value2.X);
            float num19 = Math.Abs(value2.Y);
            float num20 = value2.Length();
            if (num18 >= (float)(screenWidth / 2) || num19 >= (float)(screenHeight / 2))
            {
                renderNow = true;
                CurrentPan *= 0.9f;
                if (_cameraPanHasBlackTransition && num20 >= new Vector2(screenWidth, screenHeight).Length() / 2f + 100f)
                {
                    _cameraPanHasBlackTransition = false;
                    NPC.ResetNetOffsets();
                    BlackFadeIn = 255;
                    if (mapTime < 5)
                    {
                        mapTime = 5;
                    }
                    maxQ = true;
                    Lighting.Clear();
                    CurrentPan = Vector2.Zero;
                    instantBGTransitionCounter = 10;
                    LocalPlayer.ForceUpdateBiomes();
                }
            }
            else if (value3 > 0.0001f)
            {
                CurrentPan += Vector2.Normalize(value2) * value3;
            }
        }
        else if (value3 > 0.0001f)
        {
            CurrentPan += Vector2.Normalize(value2) * value3;
        }
        screenPosition.X += CurrentPan.X;
        screenPosition.Y += CurrentPan.Y * Main.player[myPlayer].gravDir;
        if (cameraLerp > 0f)
        {
            if (Vector2.Distance(value, screenPosition) - Main.player[myPlayer].velocity.Length() < 0.25f || (cameraGamePadLerp && !PlayerInput.UsingGamepad))
            {
                cameraLerp = 0f;
                cameraGamePadLerp = false;
            }
            else
            {
                screenPosition = Vector2.Lerp(value, screenPosition, cameraLerp);
            }
        }
        instance.CameraModifiers.ApplyTo(ref screenPosition);
        screenPosition.X = (int)screenPosition.X;
        screenPosition.Y = (int)screenPosition.Y;
        ClampScreenPositionToWorld();
    }
 
    public static bool IsItDay()
    {
        if (remixWorld)
        {
            return false;
        }
        return dayTime;
    }
 
    public static double starGameMath(double value = 1.0)
    {
        if (!starGame)
        {
            return 1.0;
        }
        double num = (double)starsHit / 200.0;
        if (num > 1.0)
        {
            num = 1.0;
        }
        return 1.0 + num * value;
    }
 
    private void DrawSunAndMoon(SceneArea sceneArea, Microsoft.Xna.Framework.Color moonColor, Microsoft.Xna.Framework.Color sunColor, float tempMushroomInfluence)
    {
        Texture2D value = TextureAssets.Sun.Value;
        int num = moonType;
        if (!TextureAssets.Moon.IndexInRange(num))
        {
            num = Utils.Clamp(num, 0, 8);
        }
        Texture2D value2 = TextureAssets.Moon[num].Value;
        int num2 = sceneArea.bgTopY;
        int num3 = (int)(time / 54000.0 * (double)(sceneArea.totalWidth + (float)(value.Width * 2))) - value.Width;
        int num4 = 0;
        float num5 = 1f;
        float rotation = (float)(time / 54000.0) * 2f - 7.3f;
        int num6 = (int)(time / 32400.0 * (double)(sceneArea.totalWidth + (float)(value2.Width * 2))) - value2.Width;
        int num7 = 0;
        float num8 = 1f;
        float num9 = (float)(time / 32400.0) * 2f - 7.3f;
        if (dayTime)
        {
            double num10;
            if (time < 27000.0)
            {
                num10 = Math.Pow(1.0 - time / 54000.0 * 2.0, 2.0);
                num4 = (int)((double)num2 + num10 * 250.0 + 180.0);
            }
            else
            {
                num10 = Math.Pow((time / 54000.0 - 0.5) * 2.0, 2.0);
                num4 = (int)((double)num2 + num10 * 250.0 + 180.0);
            }
            num5 = (float)(1.2 - num10 * 0.4);
        }
        else
        {
            double num11;
            if (time < 16200.0)
            {
                num11 = Math.Pow(1.0 - time / 32400.0 * 2.0, 2.0);
                num7 = (int)((double)num2 + num11 * 250.0 + 180.0);
            }
            else
            {
                num11 = Math.Pow((time / 32400.0 - 0.5) * 2.0, 2.0);
                num7 = (int)((double)num2 + num11 * 250.0 + 180.0);
            }
            num8 = (float)(1.2 - num11 * 0.4);
        }
        num5 *= ForcedMinimumZoom;
        num8 *= ForcedMinimumZoom;
        if (starGame)
        {
            if (WorldGen.generatingWorld)
            {
                alreadyGrabbingSunOrMoon = true;
                if (rand.Next(60) == 0)
                {
                    for (int i = 0; i < numStars; i++)
                    {
                        if (star[i].hidden)
                        {
                            Star.SpawnStars(i);
                        }
                    }
                }
                if (dayTime)
                {
                    dayTime = false;
                    time = 0.0;
                }
            }
            else
            {
                starGame = false;
            }
        }
        else
        {
            starsHit = 0;
        }
        if (dayTime)
        {
            if ((remixWorld && !gameMenu) || WorldGen.remixWorldGen)
            {
                return;
            }
            num5 *= 1.1f;
            float num12 = 1f - tempMushroomInfluence;
            num12 -= cloudAlpha * 1.5f * atmo;
            if (num12 < 0f)
            {
                num12 = 0f;
            }
            Microsoft.Xna.Framework.Color color = new Microsoft.Xna.Framework.Color((byte)(255f * num12), (byte)((float)(int)sunColor.G * num12), (byte)((float)(int)sunColor.B * num12), (byte)(255f * num12));
            Microsoft.Xna.Framework.Color color2 = new Microsoft.Xna.Framework.Color((byte)((float)(int)sunColor.R * num12), (byte)((float)(int)sunColor.G * num12), (byte)((float)(int)sunColor.B * num12), (byte)((float)(int)sunColor.B * num12));
            bool flag = false;
            if (eclipse)
            {
                value = TextureAssets.Sun3.Value;
                flag = true;
            }
            else if (!gameMenu && player[myPlayer].head == 12)
            {
                value = TextureAssets.Sun2.Value;
                flag = true;
            }
            if (flag)
            {
                color2 = new Microsoft.Xna.Framework.Color((byte)((float)(int)sunColor.R * num12), (byte)((float)(int)sunColor.G * num12), (byte)((float)(int)sunColor.B * num12), (byte)((float)(sunColor.B - 60) * num12));
            }
            Vector2 origin = value.Size() / 2f;
            Vector2 position = new Vector2(num3, num4 + sunModY) + sceneArea.SceneLocalScreenPositionOffset;
            spriteBatch.Draw(value, position, null, color, rotation, origin, num5, SpriteEffects.None, 0f);
            spriteBatch.Draw(value, position, null, color2, rotation, origin, num5, SpriteEffects.None, 0f);
        }
        if (!dayTime)
        {
            float num13 = 1f - cloudAlpha * 1.5f * atmo;
            if (num13 < 0f)
            {
                num13 = 0f;
            }
            moonColor *= num13;
            Vector2 position2 = new Vector2(num6, num7 + moonModY) + sceneArea.SceneLocalScreenPositionOffset;
            if (WorldGen.drunkWorldGen)
            {
                spriteBatch.Draw(TextureAssets.SmileyMoon.Value, position2, new Microsoft.Xna.Framework.Rectangle(0, 0, TextureAssets.SmileyMoon.Width(), TextureAssets.SmileyMoon.Height()), moonColor, num9 / 2f + (float)Math.PI, new Vector2(TextureAssets.SmileyMoon.Width() / 2, TextureAssets.SmileyMoon.Width() / 2), num8, SpriteEffects.None, 0f);
            }
            else if (pumpkinMoon)
            {
                spriteBatch.Draw(TextureAssets.PumpkinMoon.Value, position2, new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.PumpkinMoon.Width() * moonPhase, TextureAssets.PumpkinMoon.Width(), TextureAssets.PumpkinMoon.Width()), moonColor, num9, new Vector2(TextureAssets.PumpkinMoon.Width() / 2, TextureAssets.PumpkinMoon.Width() / 2), num8, SpriteEffects.None, 0f);
            }
            else if (snowMoon)
            {
                spriteBatch.Draw(TextureAssets.SnowMoon.Value, position2, new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.SnowMoon.Width() * moonPhase, TextureAssets.SnowMoon.Width(), TextureAssets.SnowMoon.Width()), moonColor, num9, new Vector2(TextureAssets.SnowMoon.Width() / 2, TextureAssets.SnowMoon.Width() / 2), num8, SpriteEffects.None, 0f);
            }
            else
            {
                spriteBatch.Draw(TextureAssets.Moon[num].Value, position2, new Microsoft.Xna.Framework.Rectangle(0, TextureAssets.Moon[num].Width() * moonPhase, TextureAssets.Moon[num].Width(), TextureAssets.Moon[num].Width()), moonColor, num9, new Vector2(TextureAssets.Moon[num].Width() / 2, TextureAssets.Moon[num].Width() / 2), num8, SpriteEffects.None, 0f);
            }
        }
        Microsoft.Xna.Framework.Rectangle value3 = ((!dayTime) ? new Microsoft.Xna.Framework.Rectangle((int)((double)num6 - (double)TextureAssets.Moon[num].Width() * 0.5 * (double)num8), (int)((double)num7 - (double)TextureAssets.Moon[num].Width() * 0.5 * (double)num8 + (double)moonModY), (int)((float)TextureAssets.Moon[num].Width() * num8), (int)((float)TextureAssets.Moon[num].Width() * num8)) : new Microsoft.Xna.Framework.Rectangle((int)((double)num3 - (double)TextureAssets.Sun.Width() * 0.5 * (double)num5), (int)((double)num4 - (double)TextureAssets.Sun.Height() * 0.5 * (double)num5 + (double)sunModY), (int)((float)TextureAssets.Sun.Width() * num5), (int)((float)TextureAssets.Sun.Width() * num5)));
        value3.Offset((int)sceneArea.SceneLocalScreenPositionOffset.X, (int)sceneArea.SceneLocalScreenPositionOffset.Y);
        Microsoft.Xna.Framework.Rectangle rectangle = new Microsoft.Xna.Framework.Rectangle(mouseX, mouseY, 1, 1);
        sunModY = (short)((double)sunModY * 0.999);
        moonModY = (short)((double)moonModY * 0.999);
        if (!gameMenu || netMode == 1)
        {
            return;
        }
        if (rectangle.Intersects(value3) || alreadyGrabbingSunOrMoon)
        {
            player[myPlayer].mouseInterface = true;
        }
        if ((mouseLeft || starGame) && hasFocus)
        {
            if (!rectangle.Intersects(value3) && !alreadyGrabbingSunOrMoon)
            {
                return;
            }
            if (dayTime)
            {
                time = 54000.0 * (double)((float)(mouseX + TextureAssets.Sun.Width()) / ((float)screenWidth + (float)(TextureAssets.Sun.Width() * 2)));
                sunModY = (short)(mouseY - num4);
                if (time > 53990.0)
                {
                    time = 53990.0;
                }
            }
            else
            {
                time = 32400.0 * (double)((float)(mouseX + TextureAssets.Moon[num].Width()) / ((float)screenWidth + (float)(TextureAssets.Moon[num].Width() * 2)));
                moonModY = (short)(mouseY - num7);
                if (time > 32390.0)
                {
                    time = 32390.0;
                }
            }
            if (time < 10.0)
            {
                time = 10.0;
            }
            alreadyGrabbingSunOrMoon = true;
        }
        else
        {
            alreadyGrabbingSunOrMoon = false;
        }
    }
 
    private void DrawStarsInBackground(SceneArea sceneArea, bool artificial)
    {
        if (netMode == 2 || ((double)screenPosition.Y >= worldSurface * 16.0 + 16.0 && shimmerAlpha == 0f))
        {
            return;
        }
        float num = 1f;
        if (GraveyardVisualIntensity > 0f)
        {
            float num2 = 1f - GraveyardVisualIntensity * 1.4f;
            if (num2 <= 0f)
            {
                return;
            }
            num *= num2;
        }
        Microsoft.Xna.Framework.Color colorOfTheSkies = ColorOfTheSkies;
        if (shimmerAlpha > 0f)
        {
            colorOfTheSkies *= 1f - shimmerAlpha;
        }
        if (remixWorld || !(255f * (1f - cloudAlpha * atmo) - (float)(int)colorOfTheSkies.R - 25f <= 0f))
        {
            for (int i = 0; i < numStars; i++)
            {
                DrawStar(ref sceneArea, num, colorOfTheSkies, i, star[i], artificial);
            }
        }
    }
 
    private void DrawStarsInForeground(SceneArea sceneArea)
    {
    }
 
    private void DrawStar(ref SceneArea sceneArea, float starOpacity, Microsoft.Xna.Framework.Color bgColorForStars, int i, Star theStar, bool artificial, bool foreground = false)
    {
        if (theStar == null || theStar.hidden)
        {
            return;
        }
        float num = shimmerAlpha;
        Microsoft.Xna.Framework.Color color = default(Microsoft.Xna.Framework.Color);
        float num2 = 1f - theStar.fadeIn;
        int num3 = (int)((float)(255 - bgColorForStars.R - 100) * theStar.twinkle * num2);
        int num4 = (int)((float)(255 - bgColorForStars.G - 100) * theStar.twinkle * num2);
        int num5 = (int)((float)(255 - bgColorForStars.B - 100) * theStar.twinkle * num2);
        num3 = (num3 + num5 + num4) / 3;
        if (num3 <= 0)
        {
            return;
        }
        num3 = (int)((double)num3 * 1.4);
        if (num3 > 255)
        {
            num3 = 255;
        }
        num4 = num3;
        num5 = num3;
        color.R = (byte)num3;
        color.G = (byte)num4;
        color.B = (byte)num5;
        color *= starOpacity;
        if (num > 0f)
        {
            Microsoft.Xna.Framework.Color value = color;
            if (i % 3 == 0)
            {
                value.G = (byte)((float)(int)color.G * (1f - num * 0f) * theStar.twinkle * theStar.twinkle);
            }
            else if (i % 3 == 1)
            {
                value.B = (byte)((float)(int)color.B * (1f - num * 0f) * theStar.twinkle * theStar.twinkle);
            }
            else if (i % 3 == 2)
            {
                value.R = (byte)((float)(int)color.R * (1f - num * 0f) * theStar.twinkle * theStar.twinkle);
            }
            color = Microsoft.Xna.Framework.Color.Lerp(color, value, num);
            if (artificial)
            {
                color *= num;
            }
            else
            {
                color *= 1f - num;
            }
        }
        Vector2 vector = new Vector2(theStar.position.X / 1920f, theStar.position.Y / 1200f) * new Vector2(sceneArea.totalWidth, sceneArea.totalHeight) + new Vector2(0f, sceneArea.bgTopY) + sceneArea.SceneLocalScreenPositionOffset;
        if (!theStar.falling)
        {
            if (vector.X < 0f)
            {
                vector.X += screenWidth;
            }
            if (vector.X > (float)screenWidth)
            {
                vector.X -= screenWidth;
            }
            if (vector.Y < 0f)
            {
                vector.Y += screenHeight;
            }
            if (vector.Y > (float)screenHeight)
            {
                vector.Y -= screenHeight;
            }
        }
        if (foreground)
        {
            Vector2 value2 = vector / ScreenSize.ToVector2();
            float fromMax = 0.35f;
            float num6 = Utils.Remap(Vector2.Distance(value2, new Vector2(0.5f, 0.5f)), 0f, fromMax, 0f, 1f);
            color *= num6;
            Microsoft.Xna.Framework.Color color2 = Lighting.GetColor((vector + screenPosition).ToTileCoordinates());
            float num7 = (float)(int)Math.Max(Math.Max(color2.R, color2.G), color2.B) / 255f;
            color *= 1f - num7;
        }
        Texture2D value3 = TextureAssets.Star[theStar.type].Value;
        Vector2 origin = value3.Size() / 2f;
        if (theStar.falling)
        {
            theStar.fadeIn = 0f;
            int num8 = theStar.fallTime;
            float num9 = 30f;
            if ((float)num8 > num9)
            {
                num8 = (int)num9;
            }
            for (int j = 1; j < num8; j++)
            {
                Vector2 vector2 = theStar.fallSpeed * j * 0.4f;
                float num10 = theStar.scale * (1f - (float)j * 1f / num9);
                Microsoft.Xna.Framework.Color color3 = color;
                _ = theStar.rotation;
                color3 *= 1f - (float)j * 1f / num9;
                spriteBatch.Draw(value3, vector - vector2, null, color3, theStar.rotation, origin, num10 * theStar.twinkle * ForcedMinimumZoom, SpriteEffects.None, 0f);
            }
            if (starGame && theStar.fallSpeed.Y > 0f && Vector2.Distance(new Vector2(mouseX, mouseY), vector) < 70f)
            {
                starsHit++;
                theStar.fallSpeed = vector - new Vector2(mouseX, mouseY);
                theStar.fallSpeed.Normalize();
                theStar.fallSpeed *= 10f;
                if (theStar.fallSpeed.Y > 0f)
                {
                    theStar.fallSpeed.Y *= -1f;
                }
                SoundEngine.PlaySound(38);
                SoundEngine.PlaySound(37);
            }
        }
        spriteBatch.Draw(value3, vector, null, color, theStar.rotation, origin, theStar.scale * theStar.twinkle * ForcedMinimumZoom, SpriteEffects.None, 0f);
    }
 
    private static void ApplyColorOfTheSkiesToTiles()
    {
        Microsoft.Xna.Framework.Color colorOfTheSkies = ColorOfTheSkies;
        tileColor.A = byte.MaxValue;
        tileColor.R = (byte)((colorOfTheSkies.R + colorOfTheSkies.G + colorOfTheSkies.B + colorOfTheSkies.R * 7) / 10);
        tileColor.G = (byte)((colorOfTheSkies.R + colorOfTheSkies.G + colorOfTheSkies.B + colorOfTheSkies.G * 7) / 10);
        tileColor.B = (byte)((colorOfTheSkies.R + colorOfTheSkies.G + colorOfTheSkies.B + colorOfTheSkies.B * 7) / 10);
        tileColor = SkyManager.Instance.ProcessTileColor(tileColor);
    }
 
    private static void UpdateAtmosphereTransparencyToSkyColor()
    {
        float num = (float)maxTilesX / 4200f;
        num *= num;
        atmo = (float)((double)((screenPosition.Y + (float)(screenHeight / 2)) / 16f - (65f + 10f * num)) / (worldSurface / 5.0));
        if (atmo < 0f)
        {
            atmo = 0f;
        }
        if (atmo > 1f)
        {
            atmo = 1f;
        }
        if (gameMenu || netMode == 2)
        {
            atmo = 1f;
        }
        Microsoft.Xna.Framework.Color colorOfTheSkies = ColorOfTheSkies;
        colorOfTheSkies.R = (byte)((float)(int)colorOfTheSkies.R * atmo);
        colorOfTheSkies.G = (byte)((float)(int)colorOfTheSkies.G * atmo);
        colorOfTheSkies.B = (byte)((float)(int)colorOfTheSkies.B * atmo);
        if ((double)atmo <= 0.01)
        {
            colorOfTheSkies = Microsoft.Xna.Framework.Color.Transparent;
        }
        ColorOfTheSkies = colorOfTheSkies;
    }
 
    private void Debug_PrettifyMap()
    {
    }
 
    private static void DrawNetplayStatusText()
    {
        if (netMode == 1 && !string.IsNullOrWhiteSpace(Netplay.Connection.StatusText))
        {
            string text = Netplay.Connection.StatusText;
            if (!Netplay.Connection.HideStatusTextPercent)
            {
                text = text + ": " + (int)((float)Netplay.Connection.StatusCount / (float)Netplay.Connection.StatusMax * 100f) + "%";
            }
            if (_netplayStatusTextSnippets == null || _oldNetplayStatusText != text)
            {
                _netplayStatusTextSnippets = ChatManager.ParseMessage(text, Microsoft.Xna.Framework.Color.White).ToArray();
                _oldNetplayStatusText = text;
            }
            Vector2 position = new Vector2(628f - ChatManager.GetStringSize(FontAssets.MouseText.Value, _netplayStatusTextSnippets, Vector2.One).X * 0.5f + (float)(screenWidth - 800), 84f);
            int hoveredSnippet;
            if (Netplay.Connection.StatusTextHasShadows)
            {
                ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, _netplayStatusTextSnippets, position, 0f, Vector2.Zero, Vector2.One, out hoveredSnippet);
            }
            else
            {
                ChatManager.DrawColorCodedString(spriteBatch, FontAssets.MouseText.Value, _netplayStatusTextSnippets, position, new Microsoft.Xna.Framework.Color(mouseTextColor, mouseTextColor, mouseTextColor, mouseTextColor), 0f, Vector2.Zero, Vector2.One, out hoveredSnippet, -1f);
            }
        }
    }
 
    private void DrawPlayerChatBubbles()
    {
        for (int i = 0; i < 255; i++)
        {
            if (player[i].active && player[i].chatOverhead.timeLeft > 0 && !player[i].dead)
            {
                Vector2 messageSize = player[i].chatOverhead.messageSize;
                Vector2 vec = player[i].Top.ToScreenPosition();
                vec.Y -= messageSize.Y + 2f;
                if (player[myPlayer].gravDir == -1f)
                {
                    vec.Y += 2f;
                }
                vec.X -= messageSize.X / 2f;
                vec.Y += player[i].gfxOffY;
                vec = vec.Floor();
                int hoveredSnippet = 0;
                ChatManager.DrawColorCodedStringWithShadow(spriteBatch, FontAssets.MouseText.Value, player[i].chatOverhead.snippets, vec, 0f, player[i].chatOverhead.color, Vector2.Zero, Vector2.One, out hoveredSnippet);
            }
        }
    }
 
    private void DrawRainInMenu()
    {
        bool flag = base.IsActive;
        Microsoft.Xna.Framework.Rectangle[] array = new Microsoft.Xna.Framework.Rectangle[6];
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = new Microsoft.Xna.Framework.Rectangle(i * 4, 0, 2, 40);
        }
        Microsoft.Xna.Framework.Color color = ColorOfTheSkies * 0.85f;
        for (int j = 0; j < maxRain; j++)
        {
            if (Main.rain[j].active)
            {
                Rain rain = Main.rain[j];
                spriteBatch.Draw(TextureAssets.Rain.Value, rain.position - screenPosition, array[rain.type], color, rain.rotation, Vector2.Zero, rain.scale, SpriteEffects.None, 0f);
                if (flag)
                {
                    rain.Update();
                }
            }
        }
    }
 
    private void DoDraw_WallsTilesNPCs()
    {
        try
        {
            CacheNPCDraws();
            CacheProjDraws();
            DrawCachedNPCs(DrawCacheNPCsMoonMoon, behindTiles: true);
            DoDraw_WallsAndBlacks();
            DrawWoF();
            DrawBackGore();
            MoonlordDeathDrama.DrawPieces(spriteBatch);
            MoonlordDeathDrama.DrawExplosions(spriteBatch);
            DrawCachedNPCs(DrawCacheNPCsBehindNonSolidTiles, behindTiles: true);
            DoDraw_Tiles_NonSolid();
            tileBatch.Begin(Rasterizer, Transform);
            DoDraw_Waterfalls();
            tileBatch.End();
        }
        catch (Exception e)
        {
            TimeLogger.DrawException(e);
        }
        spriteBatch.End();
        try
        {
            bool detectCreature = player[myPlayer].detectCreature;
            if (!detectCreature)
            {
                DoDraw_DrawNPCsBehindTiles();
            }
            DoDraw_Tiles_Solid();
            if (detectCreature)
            {
                DoDraw_DrawNPCsBehindTiles();
            }
            DrawPlayers_BehindNPCs();
            DoDraw_DrawNPCsOverTiles();
            TimeLogger.DetailedDrawReset();
        }
        catch (Exception e2)
        {
            TimeLogger.DrawException(e2);
        }
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
    }
 
    private void DoDraw_Waterfalls()
    {
        waterfallManager.Draw(spriteBatch);
        TimeLogger.DetailedDrawTime(16);
    }
 
    private void DoDraw_Tiles_Solid()
    {
        TilesRenderer.PreDrawTiles(solidLayer: true, !drawToScreen, intoRenderTargets: false);
        tileBatch.Begin(Rasterizer, Transform);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        try
        {
            if (drawToScreen)
            {
                DrawTiles(solidLayer: true, !drawToScreen, intoRenderTargets: false);
            }
            else
            {
                spriteBatch.Draw(tileTarget, sceneTilePos - screenPosition, Microsoft.Xna.Framework.Color.White);
                TimeLogger.DetailedDrawTime(17);
            }
        }
        catch (Exception e)
        {
            TimeLogger.DrawException(e);
        }
        tileBatch.End();
        spriteBatch.End();
        DrawTileEntities(solidLayer: true, !drawToScreen, intoRenderTargets: false);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        try
        {
            player[myPlayer].hitReplace.DrawFreshAnimations(spriteBatch);
            player[myPlayer].hitTile.DrawFreshAnimations(spriteBatch);
        }
        catch (Exception e2)
        {
            TimeLogger.DrawException(e2);
        }
        spriteBatch.End();
    }
 
    private void DoDraw_Tiles_NonSolid()
    {
        TilesRenderer.PreDrawTiles(solidLayer: false, !drawToScreen, intoRenderTargets: false);
        if (drawToScreen)
        {
            DrawTiles(solidLayer: false, !drawToScreen, intoRenderTargets: false);
            TimeLogger.DetailedDrawReset();
        }
        else
        {
            spriteBatch.Draw(tile2Target, sceneTile2Pos - screenPosition, Microsoft.Xna.Framework.Color.White);
            TimeLogger.DetailedDrawTime(15);
        }
        spriteBatch.End();
        try
        {
            DrawTileEntities(solidLayer: false, !drawToScreen, intoRenderTargets: false);
        }
        catch (Exception e)
        {
            TimeLogger.DrawException(e);
        }
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
    }
 
    private void DoDraw_DrawNPCsOverTiles()
    {
        DrawCachedProjs(DrawCacheProjsBehindNPCs);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        try
        {
            DrawNPCs();
            DrawCachedNPCs(DrawCacheNPCProjectiles, behindTiles: false);
            TimeLogger.DetailedDrawTime(19);
        }
        catch (Exception e)
        {
            TimeLogger.DrawException(e);
        }
        spriteBatch.End();
    }
 
    private void DoDraw_DrawNPCsBehindTiles()
    {
        DrawCachedProjs(DrawCacheProjsBehindNPCsAndTiles);
        spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, DefaultSamplerState, DepthStencilState.None, Rasterizer, null, Transform);
        try
        {
            DrawNPCs(behindTiles: true);
            TimeLogger.DetailedDrawTime(18);
        }
        catch (Exception e)
        {
            TimeLogger.DrawException(e);
        }
        spriteBatch.End();
    }
 
    private void DrawBackGore()
    {
        if (!drawBackGore)
        {
            return;
        }
        drawBackGore = false;
        if (ignoreErrors)
        {
            try
            {
                DrawGoreBehind();
                return;
            }
            catch (Exception e)
            {
                TimeLogger.DrawException(e);
                return;
            }
        }
        DrawGoreBehind();
    }
 
    private void DoDraw_WallsAndBlacks()
    {
        if (drawToScreen)
        {
            DrawBlack();
            tileBatch.Begin();
            DrawWalls();
            tileBatch.End();
        }
        else
        {
            spriteBatch.Draw(blackTarget, sceneTilePos - screenPosition, Microsoft.Xna.Framework.Color.White);
            TimeLogger.DetailedDrawTime(13);
            spriteBatch.Draw(wallTarget, sceneWallPos - screenPosition, Microsoft.Xna.Framework.Color.White);
            TimeLogger.DetailedDrawTime(14);
        }
        Overlays.Scene.Draw(spriteBatch, RenderLayers.Walls);
    }
 
    private static void SetBackColor(InfoToSetBackColor info, out Microsoft.Xna.Framework.Color sunColor, out Microsoft.Xna.Framework.Color moonColor)
    {
        double num = time;
        Microsoft.Xna.Framework.Color bgColorToSet = Microsoft.Xna.Framework.Color.White;
        sunColor = Microsoft.Xna.Framework.Color.White;
        moonColor = Microsoft.Xna.Framework.Color.White;
        float num2 = 0f;
        bool isInGameMenuOrIsServer = info.isInGameMenuOrIsServer;
        if (dayTime)
        {
            if (num < 13500.0)
            {
                num2 = (float)(num / 13500.0);
                sunColor.R = (byte)(num2 * 200f + 55f);
                sunColor.G = (byte)(num2 * 180f + 75f);
                sunColor.B = (byte)(num2 * 250f + 5f);
                bgColorToSet.R = (byte)(num2 * 230f + 25f);
                bgColorToSet.G = (byte)(num2 * 220f + 35f);
                bgColorToSet.B = (byte)(num2 * 220f + 35f);
            }
            if (num > 45900.0)
            {
                num2 = (float)(1.0 - (num / 54000.0 - 0.85) * 6.666666666666667);
                sunColor.R = (byte)(num2 * 120f + 55f);
                sunColor.G = (byte)(num2 * 100f + 25f);
                sunColor.B = (byte)(num2 * 120f + 55f);
                bgColorToSet.R = (byte)(num2 * 200f + 35f);
                bgColorToSet.G = (byte)(num2 * 85f + 35f);
                bgColorToSet.B = (byte)(num2 * 135f + 35f);
            }
            else if (num > 37800.0)
            {
                num2 = (float)(1.0 - (num / 54000.0 - 0.7) * 6.666666666666667);
                sunColor.R = (byte)(num2 * 80f + 175f);
                sunColor.G = (byte)(num2 * 130f + 125f);
                sunColor.B = (byte)(num2 * 100f + 155f);
                bgColorToSet.R = (byte)(num2 * 20f + 235f);
                bgColorToSet.G = (byte)(num2 * 135f + 120f);
                bgColorToSet.B = (byte)(num2 * 85f + 170f);
            }
        }
        if (!dayTime)
        {
            if (info.BloodMoonActive)
            {
                if (num < 16200.0)
                {
                    num2 = (float)(1.0 - num / 16200.0);
                    moonColor.R = (byte)(num2 * 10f + 205f);
                    moonColor.G = (byte)(num2 * 170f + 55f);
                    moonColor.B = (byte)(num2 * 200f + 55f);
                    bgColorToSet.R = (byte)(40f - num2 * 40f + 35f);
                    bgColorToSet.G = (byte)(num2 * 20f + 15f);
                    bgColorToSet.B = (byte)(num2 * 20f + 15f);
                }
                else if (num >= 16200.0)
                {
                    num2 = (float)((num / 32400.0 - 0.5) * 2.0);
                    moonColor.R = (byte)(num2 * 50f + 205f);
                    moonColor.G = (byte)(num2 * 100f + 155f);
                    moonColor.B = (byte)(num2 * 100f + 155f);
                    moonColor.R = (byte)(num2 * 10f + 205f);
                    moonColor.G = (byte)(num2 * 170f + 55f);
                    moonColor.B = (byte)(num2 * 200f + 55f);
                    bgColorToSet.R = (byte)(40f - num2 * 40f + 35f);
                    bgColorToSet.G = (byte)(num2 * 20f + 15f);
                    bgColorToSet.B = (byte)(num2 * 20f + 15f);
                }
            }
            else if (num < 16200.0)
            {
                num2 = (float)(1.0 - num / 16200.0);
                moonColor.R = (byte)(num2 * 10f + 205f);
                moonColor.G = (byte)(num2 * 70f + 155f);
                moonColor.B = (byte)(num2 * 100f + 155f);
                bgColorToSet.R = (byte)(num2 * 30f + 5f);
                bgColorToSet.G = (byte)(num2 * 30f + 5f);
                bgColorToSet.B = (byte)(num2 * 30f + 5f);
            }
            else if (num >= 16200.0)
            {
                num2 = (float)((num / 32400.0 - 0.5) * 2.0);
                moonColor.R = (byte)(num2 * 50f + 205f);
                moonColor.G = (byte)(num2 * 100f + 155f);
                moonColor.B = (byte)(num2 * 100f + 155f);
                bgColorToSet.R = (byte)(num2 * 20f + 5f);
                bgColorToSet.G = (byte)(num2 * 30f + 5f);
                bgColorToSet.B = (byte)(num2 * 30f + 5f);
            }
            if (dontStarveWorld)
            {
                DontStarveSeed.ModifyNightColor(ref bgColorToSet, ref moonColor);
            }
        }
        if (cloudAlpha > 0f && !remixWorld)
        {
            float num3 = 1f - cloudAlpha * 0.9f * atmo;
            bgColorToSet.R = (byte)((float)(int)bgColorToSet.R * num3);
            bgColorToSet.G = (byte)((float)(int)bgColorToSet.G * num3);
            bgColorToSet.B = (byte)((float)(int)bgColorToSet.B * num3);
        }
        if (info.GraveyardInfluence > 0f && !remixWorld)
        {
            float num4 = 1f - info.GraveyardInfluence * 0.6f;
            bgColorToSet.R = (byte)((float)(int)bgColorToSet.R * num4);
            bgColorToSet.G = (byte)((float)(int)bgColorToSet.G * num4);
            bgColorToSet.B = (byte)((float)(int)bgColorToSet.B * num4);
        }
        if (isInGameMenuOrIsServer && !dayTime)
        {
            bgColorToSet.R = 35;
            bgColorToSet.G = 35;
            bgColorToSet.B = 35;
        }
        if (info.CorruptionBiomeInfluence > 0f)
        {
            float num5 = info.CorruptionBiomeInfluence;
            if (num5 > 1f)
            {
                num5 = 1f;
            }
            int r = bgColorToSet.R;
            int g = bgColorToSet.G;
            int b = bgColorToSet.B;
            r -= (int)(90f * num5 * ((float)(int)bgColorToSet.R / 255f));
            g -= (int)(140f * num5 * ((float)(int)bgColorToSet.G / 255f));
            b -= (int)(70f * num5 * ((float)(int)bgColorToSet.B / 255f));
            if (r < 15)
            {
                r = 15;
            }
            if (g < 15)
            {
                g = 15;
            }
            if (b < 15)
            {
                b = 15;
            }
            DontStarveSeed.FixBiomeDarkness(ref bgColorToSet, ref r, ref g, ref b);
            bgColorToSet.R = (byte)r;
            bgColorToSet.G = (byte)g;
            bgColorToSet.B = (byte)b;
            r = sunColor.R;
            g = sunColor.G;
            b = sunColor.B;
            r -= (int)(100f * num5 * ((float)(int)sunColor.R / 255f));
            g -= (int)(100f * num5 * ((float)(int)sunColor.G / 255f));
            b -= (int)(0f * num5 * ((float)(int)sunColor.B / 255f));
            if (r < 15)
            {
                r = 15;
            }
            if (g < 15)
            {
                g = 15;
            }
            if (b < 15)
            {
                b = 15;
            }
            sunColor.R = (byte)r;
            sunColor.G = (byte)g;
            sunColor.B = (byte)b;
        }
        if (info.CrimsonBiomeInfluence > 0f)
        {
            float num6 = info.CrimsonBiomeInfluence;
            if (num6 > 1f)
            {
                num6 = 1f;
            }
            int r2 = bgColorToSet.R;
            int g2 = bgColorToSet.G;
            int b2 = bgColorToSet.B;
            r2 -= (int)(40f * num6 * ((float)(int)bgColorToSet.G / 255f));
            g2 -= (int)(110f * num6 * ((float)(int)bgColorToSet.G / 255f));
            b2 -= (int)(140f * num6 * ((float)(int)bgColorToSet.B / 255f));
            if (r2 < 15)
            {
                r2 = 15;
            }
            if (g2 < 15)
            {
                g2 = 15;
            }
            if (b2 < 15)
            {
                b2 = 15;
            }
            DontStarveSeed.FixBiomeDarkness(ref bgColorToSet, ref r2, ref g2, ref b2);
            bgColorToSet.R = (byte)r2;
            bgColorToSet.G = (byte)g2;
            bgColorToSet.B = (byte)b2;
            r2 = sunColor.R;
            g2 = sunColor.G;
            b2 = sunColor.B;
            g2 -= (int)(90f * num6 * ((float)(int)sunColor.G / 255f));
            b2 -= (int)(110f * num6 * ((float)(int)sunColor.B / 255f));
            if (r2 < 15)
            {
                r2 = 15;
            }
            if (g2 < 15)
            {
                g2 = 15;
            }
            if (b2 < 15)
            {
                b2 = 15;
            }
            sunColor.R = (byte)r2;
            sunColor.G = (byte)g2;
            sunColor.B = (byte)b2;
        }
        if (info.JungleBiomeInfluence > 0f)
        {
            float num7 = info.JungleBiomeInfluence;
            if (num7 > 1f)
            {
                num7 = 1f;
            }
            int r3 = bgColorToSet.R;
            int G = bgColorToSet.G;
            int b3 = bgColorToSet.B;
            r3 -= (int)(40f * num7 * ((float)(int)bgColorToSet.R / 255f));
            b3 -= (int)(70f * num7 * ((float)(int)bgColorToSet.B / 255f));
            if (G > 255)
            {
                G = 255;
            }
            if (G < 15)
            {
                G = 15;
            }
            if (r3 > 255)
            {
                r3 = 255;
            }
            if (r3 < 15)
            {
                r3 = 15;
            }
            if (b3 < 15)
            {
                b3 = 15;
            }
            DontStarveSeed.FixBiomeDarkness(ref bgColorToSet, ref r3, ref G, ref b3);
            bgColorToSet.R = (byte)r3;
            bgColorToSet.G = (byte)G;
            bgColorToSet.B = (byte)b3;
            r3 = sunColor.R;
            G = sunColor.G;
            b3 = sunColor.B;
            r3 -= (int)(30f * num7 * ((float)(int)sunColor.R / 255f));
            b3 -= (int)(10f * num7 * ((float)(int)sunColor.B / 255f));
            if (r3 < 15)
            {
                r3 = 15;
            }
            if (G < 15)
            {
                G = 15;
            }
            if (b3 < 15)
            {
                b3 = 15;
            }
            sunColor.R = (byte)r3;
            sunColor.G = (byte)G;
            sunColor.B = (byte)b3;
        }
        if (info.MushroomBiomeInfluence > 0f)
        {
            float mushroomBiomeInfluence = info.MushroomBiomeInfluence;
            int r4 = bgColorToSet.R;
            int g3 = bgColorToSet.G;
            int b4 = bgColorToSet.B;
            g3 -= (int)(250f * mushroomBiomeInfluence * ((float)(int)bgColorToSet.G / 255f));
            r4 -= (int)(250f * mushroomBiomeInfluence * ((float)(int)bgColorToSet.R / 255f));
            b4 -= (int)(250f * mushroomBiomeInfluence * ((float)(int)bgColorToSet.B / 255f));
            if (g3 < 15)
            {
                g3 = 15;
            }
            if (r4 < 15)
            {
                r4 = 15;
            }
            if (b4 < 15)
            {
                b4 = 15;
            }
            DontStarveSeed.FixBiomeDarkness(ref bgColorToSet, ref r4, ref g3, ref b4);
            bgColorToSet.R = (byte)r4;
            bgColorToSet.G = (byte)g3;
            bgColorToSet.B = (byte)b4;
            r4 = sunColor.R;
            g3 = sunColor.G;
            b4 = sunColor.B;
            g3 -= (int)(10f * mushroomBiomeInfluence * ((float)(int)sunColor.G / 255f));
            r4 -= (int)(30f * mushroomBiomeInfluence * ((float)(int)sunColor.R / 255f));
            b4 -= (int)(10f * mushroomBiomeInfluence * ((float)(int)sunColor.B / 255f));
            if (r4 < 15)
            {
                r4 = 15;
            }
            if (g3 < 15)
            {
                g3 = 15;
            }
            if (b4 < 15)
            {
                b4 = 15;
            }
            sunColor.R = (byte)r4;
            sunColor.G = (byte)g3;
            sunColor.B = (byte)b4;
            r4 = moonColor.R;
            g3 = moonColor.G;
            b4 = moonColor.B;
            g3 -= (int)(140f * mushroomBiomeInfluence * ((float)(int)moonColor.R / 255f));
            r4 -= (int)(170f * mushroomBiomeInfluence * ((float)(int)moonColor.G / 255f));
            b4 -= (int)(190f * mushroomBiomeInfluence * ((float)(int)moonColor.B / 255f));
            if (r4 < 15)
            {
                r4 = 15;
            }
            if (g3 < 15)
            {
                g3 = 15;
            }
            if (b4 < 15)
            {
                b4 = 15;
            }
            moonColor.R = (byte)r4;
            moonColor.G = (byte)g3;
            moonColor.B = (byte)b4;
        }
        byte minimalLight = 15;
        switch (GetMoonPhase())
        {
        case MoonPhase.Empty:
            minimalLight = 11;
            break;
        case MoonPhase.QuarterAtLeft:
        case MoonPhase.QuarterAtRight:
            minimalLight = 13;
            break;
        case MoonPhase.HalfAtLeft:
        case MoonPhase.HalfAtRight:
            minimalLight = 15;
            break;
        case MoonPhase.ThreeQuartersAtLeft:
        case MoonPhase.ThreeQuartersAtRight:
            minimalLight = 17;
            break;
        case MoonPhase.Full:
            minimalLight = 19;
            break;
        }
        if (dontStarveWorld)
        {
            DontStarveSeed.ModifyMinimumLightColorAtNight(ref minimalLight);
        }
        if (bgColorToSet.R < minimalLight)
        {
            bgColorToSet.R = minimalLight;
        }
        if (bgColorToSet.G < minimalLight)
        {
            bgColorToSet.G = minimalLight;
        }
        if (bgColorToSet.B < minimalLight)
        {
            bgColorToSet.B = minimalLight;
        }
        if (info.BloodMoonActive)
        {
            if (bgColorToSet.R < 25)
            {
                bgColorToSet.R = 25;
            }
            if (bgColorToSet.G < 25)
            {
                bgColorToSet.G = 25;
            }
            if (bgColorToSet.B < 25)
            {
                bgColorToSet.B = 25;
            }
        }
        if (eclipse && dayTime)
        {
            float num8 = 1242f;
            eclipseLight = (float)(num / (double)num8);
            if (eclipseLight > 1f)
            {
                eclipseLight = 1f;
            }
        }
        else if (eclipseLight > 0f)
        {
            eclipseLight -= 0.01f;
            if (eclipseLight < 0f)
            {
                eclipseLight = 0f;
            }
        }
        if (eclipseLight > 0f)
        {
            float num9 = 1f - 0.925f * eclipseLight;
            float num10 = 1f - 0.96f * eclipseLight;
            float num11 = 1f - 1f * eclipseLight;
            int num12 = (int)((float)(int)bgColorToSet.R * num9);
            int num13 = (int)((float)(int)bgColorToSet.G * num10);
            int num14 = (int)((float)(int)bgColorToSet.B * num11);
            bgColorToSet.R = (byte)num12;
            bgColorToSet.G = (byte)num13;
            bgColorToSet.B = (byte)num14;
            sunColor.R = byte.MaxValue;
            sunColor.G = 127;
            sunColor.B = 67;
            if (bgColorToSet.R < 20)
            {
                bgColorToSet.R = 20;
            }
            if (bgColorToSet.G < 10)
            {
                bgColorToSet.G = 10;
            }
            if (!Lighting.NotRetro)
            {
                if (bgColorToSet.R < 20)
                {
                    bgColorToSet.R = 20;
                }
                if (bgColorToSet.G < 14)
                {
                    bgColorToSet.G = 14;
                }
                if (bgColorToSet.B < 6)
                {
                    bgColorToSet.B = 6;
                }
            }
        }
        if ((remixWorld && !gameMenu) || WorldGen.remixWorldGen)
        {
            bgColorToSet.R = 1;
            bgColorToSet.G = 1;
            bgColorToSet.B = 1;
        }
        if (lightning > 0f)
        {
            float value = (float)(int)bgColorToSet.R / 255f;
            float value2 = (float)(int)bgColorToSet.G / 255f;
            float value3 = (float)(int)bgColorToSet.B / 255f;
            value = MathHelper.Lerp(value, 1f, lightning);
            value2 = MathHelper.Lerp(value2, 1f, lightning);
            value3 = MathHelper.Lerp(value3, 1f, lightning);
            bgColorToSet.R = (byte)(value * 255f);
            bgColorToSet.G = (byte)(value2 * 255f);
            bgColorToSet.B = (byte)(value3 * 255f);
        }
        if (!info.BloodMoonActive)
        {
            moonColor = Microsoft.Xna.Framework.Color.White;
        }
        ColorOfTheSkies = bgColorToSet;
    }
 
    private void DoLightTiles()
    {
        GetAreaToLight(out firstTileX, out lastTileX, out firstTileY, out lastTileY);
        if (!drawSkip)
        {
            Lighting.LightTiles(firstTileX, lastTileX, firstTileY, lastTileY);
        }
    }
 
    public static void GetAreaToLight(out int firstTileX, out int lastTileX, out int firstTileY, out int lastTileY)
    {
        Vector2 vector = Camera.ScaledPosition;
        Vector2 vector2 = Camera.ScaledSize;
        if (!Lighting.UsingNewLighting)
        {
            vector = Camera.UnscaledPosition;
            vector2 = Camera.UnscaledSize;
        }
        firstTileX = (int)Math.Floor(vector.X / 16f) - 1;
        lastTileX = (int)Math.Floor((vector.X + vector2.X) / 16f) + 2;
        firstTileY = (int)Math.Floor(vector.Y / 16f) - 1;
        lastTileY = (int)Math.Floor((vector.Y + vector2.Y) / 16f) + 2;
    }
 
    private static void ClampScreenPositionToWorld()
    {
        Vector2 input = new Vector2(leftWorld + 656f, topWorld + 656f) - GameViewMatrix.Translation;
        Vector2 input2 = new Vector2(rightWorld - (float)screenWidth / GameViewMatrix.Zoom.X - 672f, bottomWorld - (float)screenHeight / GameViewMatrix.Zoom.Y - 672f) - GameViewMatrix.Translation;
        input = Utils.Round(input);
        input2 = Utils.Round(input2);
        screenPosition = Vector2.Clamp(screenPosition, input, input2);
    }
 
    private void DrawBG()
    {
        float num = Math.Min(PlayerInput.RealScreenHeight, LogicCheckScreenHeight);
        float num2 = screenPosition.Y + (float)(screenHeight / 2) - num / 2f;
        scAdj = (float)(worldSurface * 16.0) / (num2 + num);
        float num3 = (float)maxTilesY * 0.15f * 16f;
        num3 -= num2;
        if (num3 < 0f)
        {
            num3 = 0f;
        }
        num3 *= 0.00025f;
        float num4 = num3 * num3;
        scAdj *= 0.45f - num4;
        if (maxTilesY <= 1200)
        {
            scAdj *= -500f;
        }
        else if (maxTilesY <= 1800)
        {
            scAdj *= -300f;
        }
        else
        {
            scAdj *= -150f;
        }
        float num5 = screenHeight;
        screenOff = num5 - 600f;
        bgTopY = (int)((double)(0f - screenPosition.Y + screenOff / 2f) / (worldSurface * 16.0) * 1200.0 + 1190.0) + (int)scAdj;
        cTop = bgTopY - 50;
        if (resetClouds)
        {
            Cloud.resetClouds();
            resetClouds = false;
        }
        bgScale = 1f;
        bgWidthScaled = (int)((float)backgroundWidth[treeMntBGSet1[0]] * bgScale);
        ColorOfSurfaceBackgroundsModified = ColorOfTheSkies;
        ColorOfSurfaceBackgroundsBase = ColorOfTheSkies;
        int preferredBGStyleForPlayer = GetPreferredBGStyleForPlayer();
        int num6 = 30;
        backgroundLayerTransitionSpeed = 0.05f;
        if (preferredBGStyleForPlayer == 0)
        {
            num6 = 60;
        }
        if (bgDelay < 0)
        {
            bgDelay++;
        }
        else if (preferredBGStyleForPlayer != bgStyle)
        {
            bgDelay++;
            if (bgDelay > num6)
            {
                bgDelay = -60;
                bgStyle = preferredBGStyleForPlayer;
                if (preferredBGStyleForPlayer == 0)
                {
                    bgDelay = 0;
                }
            }
        }
        else if (bgDelay > 0)
        {
            bgDelay--;
        }
        if (gameMenu)
        {
            backgroundLayerTransitionSpeed = 0.02f;
            if (!dayTime)
            {
                bgStyle = 1;
            }
            else
            {
                bgStyle = 0;
            }
            preferredBGStyleForPlayer = bgStyle;
            if (WorldGen.drunkWorldGen)
            {
                bgStyle = 9;
            }
        }
        if (instantBGTransitionCounter > 0)
        {
            instantBGTransitionCounter--;
            bgStyle = preferredBGStyleForPlayer;
            backgroundLayerTransitionSpeed = 1f;
        }
        UpdateBGVisibility_BackLayer(null, null);
        UpdateBGVisibility_FrontLayer(null, null);
        try
        {
            DrawSurfaceBG();
            if (BackgroundEnabled)
            {
                DrawUnderworldBackground(flat: false);
            }
        }
        catch (Exception ex)
        {
            if (!ignoreErrors)
            {
                throw ex;
            }
            TimeLogger.DrawException(ex);
        }
        TimeLogger.DetailedDrawTime(8);
    }
 
    private void UpdateBGVisibility_FrontLayer(int? targetBiomeOverride, float? transitionAmountOverride)
    {
        int value = bgStyle;
        if (targetBiomeOverride.HasValue)
        {
            value = targetBiomeOverride.Value;
        }
        float value2 = backgroundLayerTransitionSpeed;
        if (transitionAmountOverride.HasValue)
        {
            value2 = transitionAmountOverride.Value;
        }
        for (int i = 0; i < bgAlphaFrontLayer.Length; i++)
        {
            if (value == i)
            {
                bgAlphaFrontLayer[i] += value2;
                if (bgAlphaFrontLayer[i] > 1f)
                {
                    bgAlphaFrontLayer[i] = 1f;
                }
            }
            else
            {
                bgAlphaFrontLayer[i] -= value2;
                if (bgAlphaFrontLayer[i] < 0f)
                {
                    bgAlphaFrontLayer[i] = 0f;
                }
            }
        }
    }
 
    private void UpdateBGVisibility_BackLayer(int? targetBiomeOverride, float? transitionAmountOverride)
    {
        int value = bgStyle;
        if (targetBiomeOverride.HasValue)
        {
            value = targetBiomeOverride.Value;
        }
        _ = backgroundLayerTransitionSpeed;
        if (transitionAmountOverride.HasValue)
        {
            _ = transitionAmountOverride.Value;
        }
        switch (value)
        {
        case 2:
            DrawBG_ModifyBGFarBackLayerAlpha(1, null, transitionAmountOverride);
            break;
        case 3:
            if (WorldGen.jungleBG == 5)
            {
                DrawBG_ModifyBGFarBackLayerAlpha(13, null, transitionAmountOverride);
            }
            else
            {
                DrawBG_ModifyBGFarBackLayerAlpha(0, null, transitionAmountOverride);
            }
            break;
        case 1:
        case 5:
            DrawBG_ModifyBGFarBackLayerAlpha(2, null, transitionAmountOverride);
            break;
        case 6:
            if (WorldGen.hallowBG == 3)
            {
                DrawBG_ModifyBGFarBackLayerAlpha(6, null, transitionAmountOverride);
            }
            else
            {
                DrawBG_ModifyBGFarBackLayerAlpha(2, null, transitionAmountOverride);
            }
            break;
        case 4:
            DrawBG_ModifyBGFarBackLayerAlpha(3, null, transitionAmountOverride);
            break;
        case 7:
            DrawBG_ModifyBGFarBackLayerAlpha(4, null, transitionAmountOverride);
            break;
        case 8:
            DrawBG_ModifyBGFarBackLayerAlpha(5, null, transitionAmountOverride);
            break;
        case 9:
            DrawBG_ModifyBGFarBackLayerAlpha(0, 6, transitionAmountOverride);
            break;
        case 10:
        case 11:
        case 12:
            DrawBG_ModifyBGFarBackLayerAlpha(value, null, transitionAmountOverride);
            break;
        default:
            DrawBG_ModifyBGFarBackLayerAlpha(0, null, transitionAmountOverride);
            break;
        }
    }
 
    public static int GetPreferredBGStyleForPlayer()
    {
        int num = bgStyle;
        int num2 = (int)((screenPosition.X + (float)(screenWidth / 2)) / 16f);
        if (WorldGen.oceanDepths((int)(screenPosition.X + (float)(screenWidth / 2)) / 16, (int)(screenPosition.Y + (float)(screenHeight / 2)) / 16))
        {
            num = (player[myPlayer].ZoneHallow ? 6 : (player[myPlayer].ZoneCorrupt ? ((SceneMetrics.BloodTileCount <= SceneMetrics.EvilTileCount) ? 1 : 8) : (player[myPlayer].ZoneCrimson ? 8 : ((SceneMetrics.HoneyBlockCount <= 400) ? 4 : 3))));
        }
        else if (player[myPlayer].ZoneGlowshroom)
        {
            num = 9;
        }
        else if (player[myPlayer].ZoneDesert)
        {
            num = (player[myPlayer].ZoneCorrupt ? 5 : (player[myPlayer].ZoneCrimson ? 5 : ((!player[myPlayer].ZoneHallow) ? 2 : 5)));
        }
        else if (player[myPlayer].ZoneHallow)
        {
            num = 6;
        }
        else if (player[myPlayer].ZoneCorrupt)
        {
            num = ((SceneMetrics.BloodTileCount <= SceneMetrics.EvilTileCount) ? 1 : 8);
        }
        else if (player[myPlayer].ZoneCrimson)
        {
            num = 8;
        }
        else if (player[myPlayer].ZoneJungle)
        {
            num = 3;
        }
        else if (player[myPlayer].ZoneSnow)
        {
            num = 7;
        }
        else
        {
            num = 0;
            if (num2 >= treeX[0])
            {
                if (WorldGen.treeBG1 != WorldGen.treeBG2 && num2 < treeX[1])
                {
                    num = 10;
                }
                else if (WorldGen.treeBG1 != WorldGen.treeBG3 && num2 < treeX[2])
                {
                    num = 11;
                }
                else if (WorldGen.treeBG1 != WorldGen.treeBG4)
                {
                    num = 12;
                }
            }
        }
        return num;
    }
 
    private void DrawBG_ModifyBGFarBackLayerAlpha(int desiredBG, int? desiredBG2 = null, float? transitionAmountOverride = null)
    {
        float value = backgroundLayerTransitionSpeed;
        if (transitionAmountOverride.HasValue)
        {
            value = transitionAmountOverride.Value;
        }
        for (int i = 0; i < bgAlphaFarBackLayer.Length; i++)
        {
            bool flag = desiredBG == i;
            flag |= desiredBG2.HasValue && desiredBG2 == i;
            bgAlphaFarBackLayer[i] = MathHelper.Clamp(bgAlphaFarBackLayer[i] + (flag ? value : (0f - value)), 0f, 1f);
        }
    }
 
    public void DrawInfernoRings()
    {
        for (int i = 0; i < 255; i++)
        {
            if (!player[i].active || player[i].outOfRange || !player[i].inferno || player[i].dead)
            {
                continue;
            }
            LoadFlameRing();
            float num = 1f;
            float num2 = 0.1f;
            float num3 = 0.9f;
            if (!gamePaused && base.IsActive)
            {
                player[i].flameRingScale += 0.004f;
            }
            if (player[i].flameRingScale < 1f)
            {
                num = player[i].flameRingScale;
            }
            else
            {
                player[i].flameRingScale = 0.8f;
                num = player[i].flameRingScale;
            }
            if (!gamePaused && base.IsActive)
            {
                player[i].flameRingRot += 0.05f;
            }
            if (player[i].flameRingRot > (float)Math.PI * 2f)
            {
                player[i].flameRingRot -= (float)Math.PI * 2f;
            }
            if (player[i].flameRingRot < (float)Math.PI * -2f)
            {
                player[i].flameRingRot += (float)Math.PI * 2f;
            }
            for (int j = 0; j < 3; j++)
            {
                float num4 = num + num2 * (float)j;
                if (num4 > 1f)
                {
                    num4 -= num2 * 2f;
                }
                float num5 = MathHelper.Lerp(0.8f, 0f, Math.Abs(num4 - num3) * 10f);
                spriteBatch.Draw(TextureAssets.FlameRing.Value, player[i].Center - screenPosition, new Microsoft.Xna.Framework.Rectangle(0, 400 * j, 400, 400), new Microsoft.Xna.Framework.Color(num5, num5, num5, num5 / 2f), player[i].flameRingRot + (float)Math.PI / 3f * (float)j, new Vector2(200f, 200f), num4, SpriteEffects.None, 0f);
            }
        }
    }
 
    private static void UpdateInvasion()
    {
        if (invasionType <= 0)
        {
            return;
        }
        if (invasionSize <= 0)
        {
            if (invasionType == 1)
            {
                NPC.SetEventFlagCleared(ref NPC.downedGoblins, 0);
                if (netMode == 2)
                {
                    NetMessage.SendData(7);
                }
                AchievementsHelper.NotifyProgressionEvent(10);
            }
            else if (invasionType == 2)
            {
                NPC.SetEventFlagCleared(ref NPC.downedFrost, 1);
                AchievementsHelper.NotifyProgressionEvent(12);
            }
            else if (invasionType == 3)
            {
                NPC.SetEventFlagCleared(ref NPC.downedPirates, 2);
                AchievementsHelper.NotifyProgressionEvent(11);
            }
            else if (invasionType == 4)
            {
                NPC.SetEventFlagCleared(ref NPC.downedMartians, 3);
                AchievementsHelper.NotifyProgressionEvent(13);
            }
            InvasionWarning();
            invasionType = 0;
            invasionDelay = 0;
        }
        if (invasionX == (double)spawnTileX)
        {
            return;
        }
        float num = dayRate;
        if (num < 1f)
        {
            num = 1f;
        }
        if (invasionX > (double)spawnTileX)
        {
            invasionX -= num;
            if (invasionX <= (double)spawnTileX)
            {
                invasionX = spawnTileX;
                InvasionWarning();
            }
            else if (num > 0f)
            {
                invasionWarn--;
            }
        }
        else if (invasionX < (double)spawnTileX)
        {
            invasionX += num;
            if (invasionX >= (double)spawnTileX)
            {
                invasionX = spawnTileX;
                InvasionWarning();
            }
            else if (num > 0f)
            {
                invasionWarn--;
            }
        }
        if (invasionWarn <= 0)
        {
            invasionWarn = 3600;
            InvasionWarning();
        }
    }
 
    private static void InvasionWarning()
    {
        LocalizedText empty = LocalizedText.Empty;
        empty = ((invasionSize <= 0) ? ((invasionType == 2) ? Lang.misc[4] : ((invasionType == 3) ? Lang.misc[24] : ((invasionType != 4) ? (empty = Lang.misc[0]) : Lang.misc[42]))) : ((invasionX < (double)spawnTileX) ? ((invasionType == 2) ? Lang.misc[5] : ((invasionType == 3) ? Lang.misc[25] : ((invasionType != 4) ? (empty = Lang.misc[1]) : LocalizedText.Empty))) : ((invasionX > (double)spawnTileX) ? ((invasionType == 2) ? Lang.misc[6] : ((invasionType == 3) ? Lang.misc[26] : ((invasionType != 4) ? (empty = Lang.misc[2]) : LocalizedText.Empty))) : ((invasionType == 2) ? Lang.misc[7] : ((invasionType == 3) ? Lang.misc[27] : ((invasionType != 4) ? (empty = Lang.misc[3]) : Lang.misc[41]))))));
        if (netMode == 0)
        {
            NewText(empty.ToString(), 175, 75);
        }
        else if (netMode == 2 && empty.Value != "")
        {
            ChatHelper.BroadcastChatMessage(NetworkText.FromKey(empty.Key), new Microsoft.Xna.Framework.Color(175, 75, 255));
        }
    }
 
    public static bool CanStartInvasion(int type = 1, bool ignoreDelay = false)
    {
        if (invasionType != 0)
        {
            return false;
        }
        if (invasionDelay != 0 && !ignoreDelay)
        {
            return false;
        }
        int num = 0;
        for (int i = 0; i < 255; i++)
        {
            if (player[i].active && player[i].statLifeMax >= 200)
            {
                num++;
            }
        }
        return num > 0;
    }
 
    public static void StartInvasion(int type = 1)
    {
        if (invasionType != 0 && invasionSize == 0)
        {
            invasionType = 0;
        }
        if (invasionType != 0)
        {
            return;
        }
        int num = 0;
        for (int i = 0; i < 255; i++)
        {
            if (player[i].active && player[i].statLifeMax >= 200)
            {
                num++;
            }
        }
        if (num > 0)
        {
            invasionType = type;
            invasionSize = 80 + 40 * num;
            if (type == 3)
            {
                invasionSize += 40 + 20 * num;
            }
            if (type == 4)
            {
                invasionSize = 160 + 40 * num;
            }
            invasionSizeStart = invasionSize;
            invasionProgress = 0;
            invasionProgressIcon = type + 3;
            invasionProgressWave = 0;
            invasionProgressMax = invasionSizeStart;
            invasionWarn = 0;
            if (type == 4)
            {
                invasionX = spawnTileX - 1;
                invasionWarn = 2;
            }
            else if (rand.Next(2) == 0)
            {
                invasionX = 0.0;
            }
            else
            {
                invasionX = maxTilesX;
            }
        }
    }
 
    public static void FakeLoadInvasionStart()
    {
        int num = 0;
        int num2 = 0;
        switch (invasionType)
        {
        case 1:
        case 2:
            num = 80;
            num2 = 40;
            break;
        case 3:
            num = 120;
            num2 = 60;
            break;
        case 4:
            num = 160;
            num2 = 40;
            break;
        }
        int num3 = (int)Math.Ceiling((float)(invasionSize - num) / (float)num2);
        invasionSizeStart = num;
        if (num3 > 0)
        {
            invasionSizeStart += num3 * num2;
        }
    }
 
    private static void UpdateClient()
    {
        if (myPlayer == 255)
        {
            Netplay.Disconnect = true;
        }
        netPlayCounter++;
        if (netPlayCounter > 3600)
        {
            netPlayCounter = 0;
        }
        if (netPlayCounter % 420 == 0)
        {
            NetMessage.SendData(13, -1, -1, null, myPlayer);
        }
        if (netPlayCounter % 900 == 0)
        {
            NetMessage.SendData(36, -1, -1, null, myPlayer);
            NetMessage.SendData(16, -1, -1, null, myPlayer);
            NetMessage.SendData(40, -1, -1, null, myPlayer);
        }
        if (Netplay.Connection.IsActive)
        {
            Netplay.Connection.TimeOutTimer++;
            if (!stopTimeOuts && Netplay.Connection.TimeOutTimer > 7200)
            {
                statusText = Lang.inter[43].Value;
                Netplay.Disconnect = true;
            }
        }
        for (int i = 0; i < 400; i++)
        {
            if (item[i].active && item[i].playerIndexTheItemIsReservedFor == myPlayer)
            {
                item[i].FindOwner(i);
            }
        }
    }
 
    private static void UpdateServer()
    {
        netPlayCounter++;
        if (netPlayCounter % 3600 == 0)
        {
            NetMessage.SendData(7);
            netPlayCounter = 0;
        }
        for (int i = 0; i < maxNetPlayers; i++)
        {
            if (player[i].active && Netplay.Clients[i].IsActive)
            {
                Netplay.Clients[i].SpamUpdate();
            }
        }
        if (Math.IEEERemainder(netPlayCounter, 900.0) == 0.0)
        {
            bool flag = true;
            int num = lastItemUpdate;
            int num2 = 0;
            while (flag)
            {
                num++;
                if (num >= 400)
                {
                    num = 0;
                }
                num2++;
                if (!Main.item[num].active || Main.item[num].playerIndexTheItemIsReservedFor == 255)
                {
                    NetMessage.SendData(21, -1, -1, null, num);
                }
                if (num2 >= maxItemUpdates || num == lastItemUpdate)
                {
                    flag = false;
                }
            }
            lastItemUpdate = num;
        }
        for (int j = 0; j < 400; j++)
        {
            Item item = Main.item[j];
            if (item.active && (item.playerIndexTheItemIsReservedFor == 255 || !player[item.playerIndexTheItemIsReservedFor].active))
            {
                item.FindOwner(j);
            }
        }
        for (int k = 0; k < 255; k++)
        {
            if (Netplay.Clients[k].IsActive)
            {
                Netplay.Clients[k].TimeOutTimer++;
                if (Netplay.Clients[k].State == 0)
                {
                    Netplay.Clients[k].TimeOutTimer += 3;
                }
                if (!stopTimeOuts && Netplay.Clients[k].TimeOutTimer > 7200)
                {
                    Netplay.Clients[k].PendingTermination = true;
                    Netplay.Clients[k].PendingTerminationApproved = true;
                }
            }
            if (player[k].active)
            {
                RemoteClient.CheckSection(k, player[k].position);
            }
        }
    }
 
    public static void NewText(string newText, byte R = byte.MaxValue, byte G = byte.MaxValue, byte B = byte.MaxValue)
    {
        chatMonitor.NewText(newText, R, G, B);
        SoundEngine.PlaySound(12);
    }
 
    public static void NewTextMultiline(string text, bool force = false, Microsoft.Xna.Framework.Color c = default(Microsoft.Xna.Framework.Color), int WidthLimit = -1)
    {
        chatMonitor.NewTextMultiline(text, force, c, WidthLimit);
        SoundEngine.PlaySound(12);
    }
 
    public static void StopRain()
    {
        rainTime = 0;
        raining = false;
        maxRaining = 0f;
    }
 
    public static void StartRain()
    {
        int num = 86400;
        int num2 = num / 24;
        int num3 = rand.Next(num2 * 8, num);
        if (rand.Next(3) == 0)
        {
            num3 += rand.Next(0, num2);
        }
        if (rand.Next(4) == 0)
        {
            num3 += rand.Next(0, num2 * 2);
        }
        if (rand.Next(5) == 0)
        {
            num3 += rand.Next(0, num2 * 2);
        }
        if (rand.Next(6) == 0)
        {
            num3 += rand.Next(0, num2 * 3);
        }
        if (rand.Next(7) == 0)
        {
            num3 += rand.Next(0, num2 * 4);
        }
        if (rand.Next(8) == 0)
        {
            num3 += rand.Next(0, num2 * 5);
        }
        float num4 = 1f;
        if (rand.Next(2) == 0)
        {
            num4 += 0.05f;
        }
        if (rand.Next(3) == 0)
        {
            num4 += 0.1f;
        }
        if (rand.Next(4) == 0)
        {
            num4 += 0.15f;
        }
        if (rand.Next(5) == 0)
        {
            num4 += 0.2f;
        }
        rainTime = (int)((float)num3 * num4);
        ChangeRain();
        raining = true;
    }
 
    private static void ChangeRain()
    {
        float num = ((cloudBGActive >= 1f || (double)numClouds > 150.0) ? ((rand.Next(3) != 0) ? ((float)rand.Next(40, 91) * 0.01f) : ((float)rand.Next(20, 91) * 0.01f)) : (((double)numClouds > 100.0) ? ((rand.Next(3) != 0) ? ((float)rand.Next(20, 61) * 0.01f) : ((float)rand.Next(10, 71) * 0.01f)) : ((rand.Next(3) != 0) ? ((float)rand.Next(5, 31) * 0.01f) : ((float)rand.Next(5, 41) * 0.01f))));
        maxRaining = num;
    }
 
    public static void StartSlimeRain(bool announce = true)
    {
        if (remixWorld || slimeRain)
        {
            return;
        }
        if (netMode == 1)
        {
            slimeRainTime = 54000.0;
            slimeRain = true;
            SkyManager.Instance.Activate("Slime", default(Vector2));
        }
        else
        {
            if (raining)
            {
                return;
            }
            if (slimeRainTime <= 0.0)
            {
                slimeRainTime = rand.Next(32400, 54000);
            }
            slimeRain = true;
            slimeRainKillCount = 0;
            if (netMode == 0)
            {
                SkyManager.Instance.Activate("Slime", default(Vector2));
                if (announce)
                {
                    slimeWarningTime = slimeWarningDelay;
                }
            }
            else if (announce)
            {
                slimeWarningTime = slimeWarningDelay;
                NetMessage.SendData(7);
            }
        }
    }
 
    public static void StopSlimeRain(bool announce = true)
    {
        if (!slimeRain)
        {
            return;
        }
        if (netMode == 1)
        {
            slimeRainTime = 0.0;
            slimeRain = false;
            SkyManager.Instance.Deactivate("Slime");
            return;
        }
        int num = 86400 * 7;
        if (hardMode)
        {
            num *= 2;
        }
        slimeRainTime = -rand.Next(3024, 6048) * 100;
        slimeRain = false;
        if (netMode == 0)
        {
            if (announce)
            {
                slimeWarningTime = slimeWarningDelay;
            }
            SkyManager.Instance.Deactivate("Slime");
        }
        else if (announce)
        {
            slimeWarningTime = slimeWarningDelay;
            NetMessage.SendData(7);
        }
    }
 
    private static void UpdateTime()
    {
        if (LanternNight.LanternsUp)
        {
            cloudBGActive = 0f;
            if (numClouds > 30)
            {
                numClouds = 30;
            }
        }
        if (ladyBugRainBoost > 0)
        {
            ladyBugRainBoost -= dayRate;
        }
        if (pumpkinMoon)
        {
            bloodMoon = false;
            snowMoon = false;
        }
        if (snowMoon)
        {
            bloodMoon = false;
        }
        if ((netMode != 1 && !gameMenu) || netMode == 2)
        {
            if (slimeRainTime > 0.0)
            {
                slimeRainTime -= dayRate;
                if (slimeRainTime <= 0.0)
                {
                    StopSlimeRain();
                }
            }
            else if (slimeRainTime < 0.0)
            {
                slimeRainTime += dayRate;
                if (slimeRainTime > 0.0)
                {
                    slimeRainTime = 0.0;
                }
            }
            if (raining)
            {
                if (!CreativePowerManager.Instance.GetPower<CreativePowers.FreezeRainPower>().Enabled)
                {
                    if (LanternNight.LanternsUp)
                    {
                        StopRain();
                    }
                    else
                    {
                        rainTime -= dayRate;
                        if (dayRate > 0)
                        {
                            int num = 86400 / dayRate / 24;
                            if (rainTime <= 0)
                            {
                                StopRain();
                            }
                            else if (rand.Next(num * 2) == 0)
                            {
                                ChangeRain();
                            }
                        }
                    }
                }
            }
            else if (!slimeRain && !LanternNight.LanternsUp && !LanternNight.NextNightIsLanternNight)
            {
                int num2 = 86400;
                num2 /= ((dayRate == 0) ? 1 : dayRate);
                if (!CreativePowerManager.Instance.GetPower<CreativePowers.FreezeRainPower>().Enabled && dayRate != 0)
                {
                    if (rand.Next((int)((double)num2 * 5.75)) == 0)
                    {
                        StartRain();
                    }
                    else if (cloudBGActive >= 1f && rand.Next((int)((double)num2 * 4.25)) == 0)
                    {
                        StartRain();
                    }
                    else if (ladyBugRainBoost > 0 && rand.Next(num2) == 0)
                    {
                        StartRain();
                    }
                }
                if (!raining && !NPC.BusyWithAnyInvasionOfSorts() && dayTime && time < 27000.0 && dayRate > 0)
                {
                    int num3 = (int)(450000.00000000006 / (double)dayRate);
                    if (!NPC.downedSlimeKing)
                    {
                        num3 /= 2;
                    }
                    if (hardMode)
                    {
                        num3 = (int)((double)num3 * 1.5);
                    }
                    bool flag = AnyPlayerReadyToFightKingSlime();
                    if (!flag)
                    {
                        num3 *= 5;
                    }
                    if (num3 > 0 && (flag || expertMode) && rand.Next(num3) == 0)
                    {
                        StartSlimeRain();
                    }
                }
            }
        }
        if (maxRaining != oldMaxRaining)
        {
            if (netMode == 2)
            {
                NetMessage.SendData(7);
            }
            oldMaxRaining = maxRaining;
        }
        UpdateTimeRate();
        double num4 = time;
        time += dayRate;
        CultistRitual.UpdateTime();
        BirthdayParty.UpdateTime();
        LanternNight.UpdateTime();
        Sandstorm.UpdateTime();
        DD2Event.UpdateTime();
        CreditsRollEvent.UpdateTime();
        WorldGen.mysticLogsEvent.UpdateTime();
        PylonSystem.Update();
        if (!dedServ)
        {
            if (NPC.MoonLordCountdown > 0)
            {
                float num5 = MathHelper.Clamp((float)Math.Sin((float)NPC.MoonLordCountdown / 60f * 0.5f) * 2f, 0f, 1f);
                num5 *= 0.75f - 0.5f * ((float)NPC.MoonLordCountdown / (float)NPC.MaxMoonLordCountdown);
                if (!Terraria.Graphics.Effects.Filters.Scene["MoonLordShake"].IsActive())
                {
                    Terraria.Graphics.Effects.Filters.Scene.Activate("MoonLordShake", Main.player[myPlayer].position);
                }
                Terraria.Graphics.Effects.Filters.Scene["MoonLordShake"].GetShader().UseIntensity(num5);
            }
            else if (Terraria.Graphics.Effects.Filters.Scene["MoonLordShake"].IsActive())
            {
                Terraria.Graphics.Effects.Filters.Scene.Deactivate("MoonLordShake");
            }
        }
        if (NPC.MoonLordCountdown > 0)
        {
            NPC.MoonLordCountdown--;
            if (NPC.MoonLordCountdown <= 0 && netMode != 1)
            {
                NPC.SpawnOnPlayer(Player.FindClosest(new Vector2(maxTilesX / 2, (float)worldSurface / 2f) * 16f, 0, 0), 398);
            }
        }
        if (NPC.taxCollector && netMode != 2 && !gameMenu)
        {
            Main.player[myPlayer].taxTimer += dayRate;
            if (Main.player[myPlayer].taxTimer >= Player.taxRate)
            {
                Main.player[myPlayer].taxTimer -= Player.taxRate;
                Main.player[myPlayer].CollectTaxes();
            }
        }
        if (netMode != 1)
        {
            UpdateSlimeRainWarning();
        }
        if (netMode != 1)
        {
            if (NPC.travelNPC)
            {
                if (!dayTime || time > 48600.0)
                {
                    WorldGen.UnspawnTravelNPC();
                }
            }
            else if (!IsFastForwardingTime() && dayTime && time < 27000.0)
            {
                int num6 = dayRate;
                if (num6 < 1)
                {
                    num6 = 1;
                }
                int num7 = (int)(27000.0 / (double)num6);
                num7 *= 4;
                if (rand.Next(num7) == 0)
                {
                    int num8 = 0;
                    for (int i = 0; i < 200; i++)
                    {
                        if (npc[i].active && npc[i].townNPC && npc[i].type != 37 && npc[i].type != 453)
                        {
                            num8++;
                        }
                    }
                    if (num8 >= 2)
                    {
                        WorldGen.SpawnTravelNPC();
                    }
                }
            }
            NPC.travelNPC = false;
        }
        bool stopEvents = ShouldNormalEventsBeAbleToStart();
        if (!dayTime)
        {
            eclipse = false;
            if (!IsFastForwardingTime() && !stopEvents)
            {
                if (WorldGen.spawnEye && netMode != 1 && time > 4860.0)
                {
                    for (int j = 0; j < 255; j++)
                    {
                        if (Main.player[j].active && !Main.player[j].dead && ((double)Main.player[j].position.Y < worldSurface * 16.0 || remixWorld))
                        {
                            NPC.SpawnOnPlayer(j, 4);
                            WorldGen.spawnEye = false;
                            break;
                        }
                    }
                }
                if (WorldGen.spawnHardBoss > 0 && netMode != 1 && time > 4860.0)
                {
                    bool flag2 = false;
                    for (int k = 0; k < 200; k++)
                    {
                        if (npc[k].active && npc[k].boss)
                        {
                            flag2 = true;
                        }
                    }
                    if (!flag2)
                    {
                        for (int l = 0; l < 255; l++)
                        {
                            if (Main.player[l].active && !Main.player[l].dead && ((double)Main.player[l].position.Y < worldSurface * 16.0 || remixWorld))
                            {
                                if (remixWorld && getGoodWorld)
                                {
                                    NPC.SpawnMechQueen(l);
                                }
                                else if (WorldGen.spawnHardBoss == 1)
                                {
                                    NPC.SpawnOnPlayer(l, 134);
                                }
                                else if (WorldGen.spawnHardBoss == 2)
                                {
                                    NPC.SpawnOnPlayer(l, 125);
                                    NPC.SpawnOnPlayer(l, 126);
                                }
                                else if (WorldGen.spawnHardBoss == 3)
                                {
                                    NPC.SpawnOnPlayer(l, 127);
                                }
                                break;
                            }
                        }
                    }
                    WorldGen.spawnHardBoss = 0;
                }
                if (netMode != 1)
                {
                    double num9 = 16200.0;
                    bool num10 = num4 < num9 && time >= num9;
                    bool flag3 = raining;
                    if (num10 && flag3 && (!NPC.downedDeerclops || rand.Next(4) == 0))
                    {
                        for (int m = 0; m < 255; m++)
                        {
                            Player player = Main.player[m];
                            if (player.active && !player.dead && !((double)player.position.Y >= worldSurface * 16.0) && player.ZoneSnow && !(player.townNPCs > 0f) && (player.statLifeMax2 >= 200 || player.statDefense >= 9) && !NPC.AnyDanger())
                            {
                                NPC.SpawnOnPlayer(m, 668);
                                break;
                            }
                        }
                    }
                }
            }
            if (time > 32400.0)
            {
                UpdateTime_StartDay(ref stopEvents);
            }
            HandleMeteorFall();
        }
        else
        {
            WorldGen.spawnHardBoss = 0;
            WorldGen.spawnEye = false;
            bloodMoon = false;
            stopMoonEvent();
            if (time > 54000.0)
            {
                UpdateTime_StartNight(ref stopEvents);
            }
            UpdateTime_SpawnTownNPCs();
        }
    }
 
    public static bool AnyPlayerReadyToFightKingSlime()
    {
        for (int i = 0; i < 255; i++)
        {
            if (player[i].active && player[i].statLifeMax > 140 && player[i].statDefense > 8)
            {
                return true;
            }
        }
        return false;
    }
 
    public static void SkipToTime(int timeToSet, bool setIsDayTime)
    {
        _ = time;
        _ = dayTime;
        while (setIsDayTime != dayTime)
        {
            bool stopEvents = ShouldNormalEventsBeAbleToStart();
            if (dayTime)
            {
                UpdateTime_StartNight(ref stopEvents);
            }
            else
            {
                UpdateTime_StartDay(ref stopEvents);
            }
        }
        time = timeToSet;
        if (netMode == 2)
        {
            NetMessage.TrySendData(7);
        }
    }
 
    public static bool ShouldNormalEventsBeAbleToStart()
    {
        if (!NPC.LunarApocalypseIsUp && !NPC.AnyNPCs(398) && NPC.MoonLordCountdown <= 0)
        {
            return LanternNight.LanternsUp;
        }
        return true;
    }
 
    public static void UpdateTime_StartNight(ref bool stopEvents)
    {
        if (fastForwardTimeToDusk)
        {
            fastForwardTimeToDusk = false;
            UpdateTimeRate();
        }
        if (moondialCooldown > 0)
        {
            moondialCooldown--;
        }
        NPC.ResetBadgerHatTime();
        NPC.freeCake = false;
        Star.NightSetup();
        NPC.setFireFlyChance();
        BirthdayParty.CheckNight();
        LanternNight.CheckNight();
        WorldGen.mysticLogsEvent.StartNight();
        WorldGen.prioritizedTownNPCType = 0;
        checkForSpawns = 0;
        if (rand.Next(50) == 0 && netMode != 1 && NPC.downedBoss2)
        {
            WorldGen.spawnMeteor = true;
        }
        if (LanternNight.LanternsUp)
        {
            stopEvents = true;
        }
        if (eclipse && netMode != 1)
        {
            AchievementsHelper.NotifyProgressionEvent(3);
        }
        eclipse = false;
        if (netMode != 1)
        {
            AchievementsHelper.NotifyProgressionEvent(0);
        }
        if (!IsFastForwardingTime() && !stopEvents)
        {
            if (!NPC.downedBoss1 && netMode != 1)
            {
                bool flag = false;
                for (int i = 0; i < 255; i++)
                {
                    if (player[i].active && player[i].statLifeMax >= 200 && player[i].statDefense > 10)
                    {
                        flag = true;
                        break;
                    }
                }
                if (flag && rand.Next(3) == 0)
                {
                    int num = 0;
                    for (int j = 0; j < 200; j++)
                    {
                        if (npc[j].active && npc[j].townNPC)
                        {
                            num++;
                        }
                    }
                    if (num >= 4)
                    {
                        WorldGen.spawnEye = true;
                        if (netMode == 0)
                        {
                            NewText(Lang.misc[9].Value, 50, byte.MaxValue, 130);
                        }
                        else if (netMode == 2)
                        {
                            ChatHelper.BroadcastChatMessage(Lang.misc[9].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                        }
                    }
                }
            }
            if (netMode != 1 && !pumpkinMoon && !DD2Event.Ongoing && !snowMoon && WorldGen.altarCount > 0 && hardMode && !WorldGen.spawnEye && rand.Next(10) == 0)
            {
                bool flag2 = false;
                for (int k = 0; k < 200; k++)
                {
                    if (npc[k].active && npc[k].boss)
                    {
                        flag2 = true;
                    }
                }
                if (!flag2 && (!NPC.downedMechBoss1 || !NPC.downedMechBoss2 || !NPC.downedMechBoss3))
                {
                    if (remixWorld && getGoodWorld)
                    {
                        if (rand.Next(2) == 0)
                        {
                            WorldGen.spawnHardBoss = rand.Next(3) + 1;
                            if (netMode == 0)
                            {
                                NewText(Lang.misc[108].Value, 50, byte.MaxValue, 130);
                            }
                            else if (netMode == 2)
                            {
                                ChatHelper.BroadcastChatMessage(Lang.misc[108].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                            }
                        }
                    }
                    else
                    {
                        for (int l = 0; l < 1000; l++)
                        {
                            int num2 = rand.Next(3) + 1;
                            if (num2 == 1 && !NPC.downedMechBoss1)
                            {
                                WorldGen.spawnHardBoss = num2;
                                if (netMode == 0)
                                {
                                    NewText(Lang.misc[28].Value, 50, byte.MaxValue, 130);
                                }
                                else if (netMode == 2)
                                {
                                    ChatHelper.BroadcastChatMessage(Lang.misc[28].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                                }
                                break;
                            }
                            if (num2 == 2 && !NPC.downedMechBoss2)
                            {
                                WorldGen.spawnHardBoss = num2;
                                if (netMode == 0)
                                {
                                    NewText(Lang.misc[29].Value, 50, byte.MaxValue, 130);
                                }
                                else if (netMode == 2)
                                {
                                    ChatHelper.BroadcastChatMessage(Lang.misc[29].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                                }
                                break;
                            }
                            if (num2 == 3 && !NPC.downedMechBoss3)
                            {
                                WorldGen.spawnHardBoss = num2;
                                if (netMode == 0)
                                {
                                    NewText(Lang.misc[30].Value, 50, byte.MaxValue, 130);
                                }
                                else if (netMode == 2)
                                {
                                    ChatHelper.BroadcastChatMessage(Lang.misc[30].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                                }
                                break;
                            }
                        }
                    }
                }
            }
            int maxValue = 9;
            if (tenthAnniversaryWorld)
            {
                maxValue = 6;
            }
            if (!WorldGen.spawnEye && moonPhase != 4 && rand.Next(maxValue) == 0 && netMode != 1)
            {
                for (int m = 0; m < 255; m++)
                {
                    if (player[m].active && player[m].statLifeMax > 120)
                    {
                        bloodMoon = true;
                        break;
                    }
                }
                if (bloodMoon)
                {
                    sundialCooldown = 0;
                    moondialCooldown = 0;
                    AchievementsHelper.NotifyProgressionEvent(4);
                    if (netMode == 0)
                    {
                        NewText(Lang.misc[8].Value, 50, byte.MaxValue, 130);
                    }
                    else if (netMode == 2)
                    {
                        ChatHelper.BroadcastChatMessage(Lang.misc[8].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                    }
                }
            }
        }
        time = 0.0;
        dayTime = false;
        if (netMode == 2)
        {
            NetMessage.SendData(7);
        }
    }
 
    public static void UpdateTime_StartDay(ref bool stopEvents)
    {
        WorldGen.ResetTreeShakes();
        if (fastForwardTimeToDawn)
        {
            fastForwardTimeToDawn = false;
            UpdateTimeRate();
        }
        AnglerQuestSwap();
        BirthdayParty.CheckMorning();
        LanternNight.CheckMorning();
        if (invasionDelay > 0)
        {
            invasionDelay--;
        }
        WorldGen.prioritizedTownNPCType = 0;
        checkForSpawns = 0;
        time = 0.0;
        if (bloodMoon && netMode != 1)
        {
            AchievementsHelper.NotifyProgressionEvent(5);
        }
        bloodMoon = false;
        CheckForMoonEventsScoreDisplay();
        CheckForMoonEventsStartingTemporarySeasons();
        checkXMas();
        checkHalloween();
        stopMoonEvent();
        dayTime = true;
        if (sundialCooldown > 0)
        {
            sundialCooldown--;
        }
        moonPhase++;
        if (moonPhase >= 8)
        {
            moonPhase = 0;
        }
        if (drunkWorld && netMode != 1)
        {
            WorldGen.crimson = !WorldGen.crimson;
        }
        if (netMode == 2)
        {
            NetMessage.SendData(7);
        }
        if (netMode == 1)
        {
            return;
        }
        AchievementsHelper.NotifyProgressionEvent(1);
        if (stopEvents)
        {
            return;
        }
        if (hardMode && NPC.downedMechBossAny && rand.Next(20) == 0)
        {
            sundialCooldown = 0;
            moondialCooldown = 0;
            eclipse = true;
            AchievementsHelper.NotifyProgressionEvent(2);
            if (eclipse)
            {
                if (remixWorld)
                {
                    if (netMode == 0)
                    {
                        NewText(Lang.misc[106].Value, 50, byte.MaxValue, 130);
                    }
                    else if (netMode == 2)
                    {
                        ChatHelper.BroadcastChatMessage(Lang.misc[106].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                    }
                }
                else if (netMode == 0)
                {
                    NewText(Lang.misc[20].Value, 50, byte.MaxValue, 130);
                }
                else if (netMode == 2)
                {
                    ChatHelper.BroadcastChatMessage(Lang.misc[20].ToNetworkText(), new Microsoft.Xna.Framework.Color(50, 255, 130));
                }
            }
            if (netMode == 2)
            {
                NetMessage.SendData(7);
            }
        }
        else
        {
            if (snowMoon || pumpkinMoon || DD2Event.Ongoing)
            {
                return;
            }
            if (WorldGen.shadowOrbSmashed)
            {
                if (!NPC.downedGoblins)
                {
                    if (rand.Next(3) == 0)
                    {
                        StartInvasion();
                    }
                }
                else if ((hardMode && rand.Next(60) == 0) || (!hardMode && rand.Next(30) == 0))
                {
                    StartInvasion();
                }
            }
            if (invasionType == 0 && hardMode && WorldGen.altarCount > 0 && ((NPC.downedPirates && rand.Next(60) == 0) || (!NPC.downedPirates && rand.Next(30) == 0)))
            {
                StartInvasion(3);
            }
        }
    }
 
    private static void HandleMeteorFall()
    {
        if (netMode != 1 && WorldGen.spawnMeteor)
        {
            if (time < 15000.0)
            {
                _canShowMeteorFall = true;
            }
            else
            {
                if (_canShowMeteorFall && time <= 16200.0)
                {
                    AmbienceServer.ForceEntitySpawn(new AmbienceServer.AmbienceSpawnInfo
                    {
                        skyEntityType = SkyEntityType.Meteor,
                        targetPlayer = -1
                    });
                }
                _canShowMeteorFall = false;
            }
        }
        if (time > 16200.0 && WorldGen.spawnMeteor)
        {
            WorldGen.spawnMeteor = false;
            WorldGen.dropMeteor();
        }
    }
 
    private static void UpdateSlimeRainWarning()
    {
        if (slimeWarningTime <= 0)
        {
            return;
        }
        slimeWarningTime--;
        if (slimeWarningTime > 0)
        {
            return;
        }
        if (netMode == 0)
        {
            if (slimeRainTime > 0.0)
            {
                NewText(Lang.gen[74].Value, 50, byte.MaxValue, 130);
            }
            else
            {
                NewText(Lang.gen[75].Value, 50, byte.MaxValue, 130);
            }
        }
        else if (slimeRainTime > 0.0)
        {
            ChatHelper.BroadcastChatMessage(NetworkText.FromKey(Lang.gen[74].Key), new Microsoft.Xna.Framework.Color(50, 255, 130));
        }
        else
        {
            ChatHelper.BroadcastChatMessage(NetworkText.FromKey(Lang.gen[75].Key), new Microsoft.Xna.Framework.Color(50, 255, 130));
        }
    }
 
    public static BestiaryUnlockProgressReport GetBestiaryProgressReport()
    {
        float num = 0f;
        int num2 = 0;
        List<BestiaryEntry> entries = BestiaryDB.Entries;
        for (int i = 0; i < entries.Count; i++)
        {
            int num3 = ((entries[i].UIInfoProvider.GetEntryUICollectionInfo().UnlockState > BestiaryEntryUnlockState.NotKnownAtAll_0) ? 1 : 0);
            num2++;
            num += (float)num3;
        }
        BestiaryUnlockProgressReport result = default(BestiaryUnlockProgressReport);
        result.EntriesTotal = num2;
        result.CompletionAmountTotal = num;
        return result;
    }
 
    private static void UpdateTime_SpawnTownNPCs()
    {
        int worldUpdateRate = WorldGen.GetWorldUpdateRate();
        if (netMode == 1 || worldUpdateRate <= 0)
        {
            return;
        }
        checkForSpawns++;
        if (checkForSpawns < 7200 / worldUpdateRate)
        {
            return;
        }
        checkForSpawns = 0;
        int num = 0;
        for (int i = 0; i < 255; i++)
        {
            if (player[i].active)
            {
                num++;
            }
        }
        for (int j = 0; j < NPCID.Count; j++)
        {
            townNPCCanSpawn[j] = false;
        }
        WorldGen.prioritizedTownNPCType = 0;
        int num2 = 0;
        int num3 = 0;
        int num4 = 0;
        int num5 = 0;
        int num6 = 0;
        int num7 = 0;
        int num8 = 0;
        int num9 = 0;
        int num10 = 0;
        int num11 = 0;
        int num12 = 0;
        int num13 = 0;
        int num14 = 0;
        int num15 = 0;
        int num16 = 0;
        int num17 = 0;
        int num18 = 0;
        int num19 = 0;
        int num20 = 0;
        int num21 = 0;
        int num22 = 0;
        int num23 = 0;
        int num24 = 0;
        int num25 = 0;
        int num26 = 0;
        int num27 = 0;
        int num28 = 0;
        int num29 = 0;
        int num30 = 0;
        int num31 = 0;
        int num32 = 0;
        int num33 = 0;
        int num34 = 0;
        int num35 = 0;
        int num36 = 0;
        int num37 = 0;
        int num38 = 0;
        int num39 = 0;
        int num40 = 0;
        for (int k = 0; k < 200; k++)
        {
            if (npc[k].active && npc[k].townNPC)
            {
                if (npc[k].type != 368 && npc[k].type != 37 && npc[k].type != 453 && !npc[k].homeless)
                {
                    WorldGen.QuickFindHome(k);
                }
                if (npc[k].type == 37)
                {
                    num7++;
                }
                if (npc[k].type == 17)
                {
                    num2++;
                }
                if (npc[k].type == 18)
                {
                    num3++;
                }
                if (npc[k].type == 19)
                {
                    num5++;
                }
                if (npc[k].type == 20)
                {
                    num4++;
                }
                if (npc[k].type == 22)
                {
                    num6++;
                }
                if (npc[k].type == 38)
                {
                    num8++;
                }
                if (npc[k].type == 54)
                {
                    num9++;
                }
                if (npc[k].type == 107)
                {
                    num11++;
                }
                if (npc[k].type == 108)
                {
                    num10++;
                }
                if (npc[k].type == 124)
                {
                    num12++;
                }
                if (npc[k].type == 142)
                {
                    num13++;
                }
                if (npc[k].type == 160)
                {
                    num14++;
                }
                if (npc[k].type == 178)
                {
                    num15++;
                }
                if (npc[k].type == 207)
                {
                    num16++;
                }
                if (npc[k].type == 208)
                {
                    num17++;
                }
                if (npc[k].type == 209)
                {
                    num18++;
                }
                if (npc[k].type == 227)
                {
                    num19++;
                }
                if (npc[k].type == 228)
                {
                    num20++;
                }
                if (npc[k].type == 229)
                {
                    num21++;
                }
                if (npc[k].type == 353)
                {
                    num22++;
                }
                if (npc[k].type == 369)
                {
                    num23++;
                }
                if (npc[k].type == 441)
                {
                    num24++;
                }
                if (npc[k].type == 550)
                {
                    num25++;
                }
                if (npc[k].type == 588)
                {
                    num26++;
                }
                if (npc[k].type == 633)
                {
                    num27++;
                }
                if (npc[k].type == 637)
                {
                    num28++;
                }
                if (npc[k].type == 638)
                {
                    num29++;
                }
                if (npc[k].type == 656)
                {
                    num30++;
                }
                if (npc[k].type == 670)
                {
                    num31++;
                }
                if (npc[k].type == 678)
                {
                    num32++;
                }
                if (npc[k].type == 679)
                {
                    num33++;
                }
                if (npc[k].type == 680)
                {
                    num34++;
                }
                if (npc[k].type == 681)
                {
                    num35++;
                }
                if (npc[k].type == 682)
                {
                    num36++;
                }
                if (npc[k].type == 683)
                {
                    num37++;
                }
                if (npc[k].type == 684)
                {
                    num38++;
                }
                if (npc[k].type == 663)
                {
                    num39++;
                }
                num40++;
            }
        }
        if (WorldGen.prioritizedTownNPCType == 0)
        {
            bool flag = NPC.SpawnAllowed_Merchant();
            bool flag2 = NPC.SpawnAllowed_ArmsDealer();
            bool flag3 = NPC.SpawnAllowed_Nurse();
            bool flag4 = NPC.SpawnAllowed_DyeTrader();
            bool flag5 = NPC.SpawnAllowed_Demolitionist();
            BestiaryUnlockProgressReport bestiaryProgressReport = GetBestiaryProgressReport();
            if (!NPC.downedBoss3 && num7 == 0)
            {
                int num41 = NPC.NewNPC(NPC.GetSpawnSourceForTownSpawn(), dungeonX * 16 + 8, dungeonY * 16, 37);
                npc[num41].homeless = false;
                npc[num41].homeTileX = dungeonX;
                npc[num41].homeTileY = dungeonY;
            }
            bool flag6 = false;
            if (rand.Next(40) == 0)
            {
                flag6 = true;
            }
            bool flag7 = flag6 && num40 >= 14;
            if (NPC.unlockedPartyGirlSpawn)
            {
                flag7 = true;
            }
            bool flag8 = BirthdayParty.GenuineParty;
            if (NPC.unlockedSlimeGreenSpawn)
            {
                flag8 = true;
            }
            if (num6 < 1)
            {
                townNPCCanSpawn[22] = true;
            }
            if (flag && num2 < 1)
            {
                townNPCCanSpawn[17] = true;
            }
            if (flag3 && num3 < 1 && num2 > 0)
            {
                townNPCCanSpawn[18] = true;
            }
            if (flag2 && num5 < 1)
            {
                townNPCCanSpawn[19] = true;
            }
            if ((NPC.downedBoss1 || NPC.downedBoss2 || NPC.downedBoss3) && num4 < 1)
            {
                townNPCCanSpawn[20] = true;
            }
            if (flag5 && num2 > 0 && num8 < 1)
            {
                townNPCCanSpawn[38] = true;
            }
            if (NPC.savedStylist && num22 < 1)
            {
                townNPCCanSpawn[353] = true;
            }
            if (NPC.savedAngler && num23 < 1)
            {
                townNPCCanSpawn[369] = true;
            }
            if (NPC.downedBoss3 && num9 < 1)
            {
                townNPCCanSpawn[54] = true;
            }
            if (NPC.savedGoblin && num11 < 1)
            {
                townNPCCanSpawn[107] = true;
            }
            if (NPC.savedTaxCollector && num24 < 1)
            {
                townNPCCanSpawn[441] = true;
            }
            if (NPC.savedWizard && num10 < 1)
            {
                townNPCCanSpawn[108] = true;
            }
            if (NPC.savedMech && num12 < 1)
            {
                townNPCCanSpawn[124] = true;
            }
            if (NPC.downedFrost && num13 < 1 && xMas)
            {
                townNPCCanSpawn[142] = true;
            }
            if (((tenthAnniversaryWorld && !remixWorld) || NPC.downedMechBossAny) && num15 < 1)
            {
                townNPCCanSpawn[178] = true;
            }
            if (flag4 && num16 < 1 && num40 >= 4)
            {
                townNPCCanSpawn[207] = true;
            }
            if (NPC.downedQueenBee && num20 < 1)
            {
                townNPCCanSpawn[228] = true;
            }
            if (NPC.downedPirates && num21 < 1)
            {
                townNPCCanSpawn[229] = true;
            }
            if (num14 < 1 && hardMode)
            {
                townNPCCanSpawn[160] = true;
            }
            if (hardMode && NPC.downedPlantBoss && num18 < 1)
            {
                townNPCCanSpawn[209] = true;
            }
            if (num40 >= 8 && num19 < 1)
            {
                townNPCCanSpawn[227] = true;
            }
            if (flag7 && num17 < 1)
            {
                townNPCCanSpawn[208] = true;
            }
            if (NPC.savedBartender && num25 < 1)
            {
                townNPCCanSpawn[550] = true;
            }
            if (NPC.savedGolfer && num26 < 1)
            {
                townNPCCanSpawn[588] = true;
            }
            if (bestiaryProgressReport.CompletionPercent >= 0.1f && num27 < 1)
            {
                townNPCCanSpawn[633] = true;
            }
            if (NPC.boughtCat && num28 < 1)
            {
                townNPCCanSpawn[637] = true;
            }
            if (NPC.boughtDog && num29 < 1)
            {
                townNPCCanSpawn[638] = true;
            }
            if (NPC.boughtBunny && num30 < 1)
            {
                townNPCCanSpawn[656] = true;
            }
            if (NPC.unlockedSlimeBlueSpawn && num31 < 1)
            {
                townNPCCanSpawn[670] = true;
            }
            if (flag8 && num32 < 1)
            {
                townNPCCanSpawn[678] = true;
            }
            if (NPC.unlockedSlimeOldSpawn && num33 < 1)
            {
                townNPCCanSpawn[679] = true;
            }
            if (NPC.unlockedSlimePurpleSpawn && num34 < 1)
            {
                townNPCCanSpawn[680] = true;
            }
            if (NPC.unlockedSlimeRainbowSpawn && num35 < 1)
            {
                townNPCCanSpawn[681] = true;
            }
            if (NPC.unlockedSlimeRedSpawn && num36 < 1)
            {
                townNPCCanSpawn[682] = true;
            }
            if (NPC.unlockedSlimeYellowSpawn && num37 < 1)
            {
                townNPCCanSpawn[683] = true;
            }
            if (NPC.unlockedSlimeCopperSpawn && num38 < 1)
            {
                townNPCCanSpawn[684] = true;
            }
            bool flag9 = num2 > 0 && num3 > 0 && num4 > 0 && num5 > 0 && num6 > 0 && num8 > 0 && num9 > 0 && num10 > 0 && num11 > 0 && num12 > 0 && num14 > 0 && num15 > 0 && num16 > 0 && num17 > 0 && num18 > 0 && num19 > 0 && num20 > 0 && num21 > 0 && num22 > 0 && num23 > 0 && num24 > 0 && num25 > 0 && num26 > 0 && num27 > 0;
            if (tenthAnniversaryWorld && !remixWorld)
            {
                flag9 = true;
            }
            if (NPC.unlockedPrincessSpawn)
            {
                flag9 = true;
            }
            if (flag9 && num39 < 1)
            {
                townNPCCanSpawn[663] = true;
            }
            int num42 = WorldGen.prioritizedTownNPCType;
            if (num42 == 0 && NPC.boughtCat && num28 < 1)
            {
                num42 = 637;
            }
            if (num42 == 0 && NPC.boughtDog && num29 < 1)
            {
                num42 = 638;
            }
            if (num42 == 0 && NPC.boughtBunny && num30 < 1)
            {
                num42 = 656;
            }
            if (num42 == 0 && NPC.unlockedSlimeBlueSpawn && num31 < 1)
            {
                num42 = 670;
            }
            if (num42 == 0 && flag8 && num32 < 1)
            {
                num42 = 678;
            }
            if (num42 == 0 && NPC.unlockedSlimeOldSpawn && num33 < 1)
            {
                num42 = 679;
            }
            if (num42 == 0 && NPC.unlockedSlimePurpleSpawn && num34 < 1)
            {
                num42 = 680;
            }
            if (num42 == 0 && NPC.unlockedSlimeRainbowSpawn && num35 < 1)
            {
                num42 = 681;
            }
            if (num42 == 0 && NPC.unlockedSlimeRedSpawn && num36 < 1)
            {
                num42 = 682;
            }
            if (num42 == 0 && NPC.unlockedSlimeYellowSpawn && num37 < 1)
            {
                num42 = 683;
            }
            if (num42 == 0 && NPC.unlockedSlimeCopperSpawn && num38 < 1)
            {
                num42 = 684;
            }
            if (num42 == 0 && num6 < 1)
            {
                num42 = 22;
            }
            if (num42 == 0 && flag && num2 < 1)
            {
                num42 = 17;
            }
            if (num42 == 0 && flag3 && num3 < 1 && num2 > 0)
            {
                num42 = 18;
            }
            if (num42 == 0 && flag2 && num5 < 1)
            {
                num42 = 19;
            }
            if (num42 == 0 && NPC.savedGoblin && num11 < 1)
            {
                num42 = 107;
            }
            if (num42 == 0 && NPC.savedTaxCollector && num24 < 1)
            {
                num42 = 441;
            }
            if (num42 == 0 && NPC.savedWizard && num10 < 1)
            {
                num42 = 108;
            }
            if (num42 == 0 && hardMode && num14 < 1)
            {
                num42 = 160;
            }
            if (num42 == 0 && (NPC.downedBoss1 || NPC.downedBoss2 || NPC.downedBoss3) && num4 < 1)
            {
                num42 = 20;
            }
            if (num42 == 0 && flag5 && num2 > 0 && num8 < 1)
            {
                num42 = 38;
            }
            if (num42 == 0 && NPC.downedQueenBee && num20 < 1)
            {
                num42 = 228;
            }
            if (num42 == 0 && NPC.downedMechBossAny && num15 < 1)
            {
                num42 = 178;
            }
            if (num42 == 0 && NPC.savedMech && num12 < 1)
            {
                num42 = 124;
            }
            if (num42 == 0 && NPC.savedAngler && num23 < 1)
            {
                num42 = 369;
            }
            if (num42 == 0 && hardMode && NPC.downedPlantBoss && num18 < 1)
            {
                num42 = 209;
            }
            if (num42 == 0 && NPC.downedPirates && num21 < 1)
            {
                num42 = 229;
            }
            if (num42 == 0 && NPC.downedBoss3 && num9 < 1)
            {
                num42 = 54;
            }
            if (num42 == 0 && NPC.savedStylist && num22 < 1)
            {
                num42 = 353;
            }
            if (num42 == 0 && num40 >= 4 && flag4 && num16 < 1)
            {
                num42 = 207;
            }
            if (num42 == 0 && num40 >= 8 && num19 < 1)
            {
                num42 = 227;
            }
            if (num42 == 0 && flag7 && num17 < 1)
            {
                num42 = 208;
            }
            if (num42 == 0 && NPC.downedFrost && num13 < 1 && xMas)
            {
                num42 = 142;
            }
            if (num42 == 0 && NPC.savedBartender && num25 < 1)
            {
                num42 = 550;
            }
            if (num42 == 0 && NPC.savedGolfer && num26 < 1)
            {
                num42 = 588;
            }
            if (num42 == 0 && bestiaryProgressReport.CompletionPercent >= 0.1f && num27 < 1)
            {
                num42 = 633;
            }
            if (num42 == 0 && flag9 && num39 < 1)
            {
                num42 = 663;
            }
            WorldGen.prioritizedTownNPCType = num42;
        }
    }
 
    public static int DamageVar(float dmg, float luck = 0f)
    {
        float num = dmg * (1f + (float)rand.Next(-15, 16) * 0.01f);
        if (luck > 0f)
        {
            if (rand.NextFloat() < luck)
            {
                float num2 = dmg * (1f + (float)rand.Next(-15, 16) * 0.01f);
                if (num2 > num)
                {
                    num = num2;
                }
            }
        }
        else if (luck < 0f && rand.NextFloat() < 0f - luck)
        {
            float num3 = dmg * (1f + (float)rand.Next(-15, 16) * 0.01f);
            if (num3 < num)
            {
                num = num3;
            }
        }
        return (int)Math.Round(num);
    }
 
    public static double CalculateDamageNPCsTake(int Damage, int Defense)
    {
        double num = (double)Damage - (double)Defense * 0.5;
        if (num < 1.0)
        {
            num = 1.0;
        }
        return num;
    }
 
    public static double CalculateDamagePlayersTakeInPVP(int Damage, int Defense)
    {
        double num = (double)Damage - (double)Defense * 0.5;
        if (num < 1.0)
        {
            num = 1.0;
        }
        return num;
    }
 
    public static double CalculateDamagePlayersTake(int Damage, int Defense)
    {
        double num = (double)Damage - (double)Defense * 0.5;
        if (masterMode)
        {
            num = Damage - Defense;
        }
        else if (expertMode)
        {
            num = (double)Damage - (double)Defense * 0.75;
        }
        if (num < 1.0)
        {
            num = 1.0;
        }
        return num;
    }
 
    public void OnTileChangeEvent(int x, int y, int count, TileChangeType eventType)
    {
        WorldGen.PlayLiquidChangeSound(eventType, x, y, count);
    }
 
    public static void ClearPendingPlayerSelectCallbacks()
    {
        _pendingCharacterSelect = null;
    }
 
    public static void SelectPlayer(PlayerFileData data)
    {
        if (_pendingCharacterSelect != null)
        {
            _pendingCharacterSelect(data);
            _pendingCharacterSelect = null;
        }
        else if (menuMultiplayer)
        {
            ServerSideCharacter = false;
            data.SetAsActive();
            SoundEngine.PlaySound(10);
            if (autoJoin)
            {
                if (Netplay.SetRemoteIP(getIP))
                {
                    menuMode = 10;
                    Netplay.StartTcpClient();
                }
                autoJoin = false;
            }
            else if (menuServer)
            {
                LoadWorlds();
                menuMode = 6;
            }
            else
            {
                menuMode = 13;
                clrInput();
            }
        }
        else
        {
            ServerSideCharacter = false;
            myPlayer = 0;
            data.SetAsActive();
            player[myPlayer].position = Vector2.Zero;
            LoadWorlds();
            SoundEngine.PlaySound(10);
            menuMode = 6;
        }
    }
 
    public static void ToggleFullScreen()
    {
        SetFullScreen(!graphics.IsFullScreen);
    }
 
    public static void SetFullScreen(bool fullscreen)
    {
        SetDisplayMode(PendingResolutionWidth, PendingResolutionHeight, fullscreen);
    }
 
    public static void SetResolution(int width, int height)
    {
        SetDisplayMode(width, height, graphics.IsFullScreen);
    }
 
    public static void SetDisplayMode(int width, int height, bool fullscreen)
    {
        bool flag = false;
        Form form = null;
        if (Platform.IsWindows)
        {
            form = (Form)Control.FromHandle(instance.Window.Handle);
            screenMaximized = form.WindowState == FormWindowState.Maximized;
            if (screenBorderless && screenMaximized && !graphics.IsFullScreen)
            {
                screenMaximized = false;
                form.WindowState = FormWindowState.Normal;
            }
            flag = form.FormBorderStyle == FormBorderStyle.None;
        }
        else
        {
            screenMaximized = false;
        }
        bool flag2 = false;
        int num3;
        int num4;
        if (screenBorderless || screenMaximized || graphics.IsFullScreen || fullscreen)
        {
            bool flag3 = false;
            if (PlayerInput.SteamDeckIsUsed)
            {
                flag3 = true;
                if (!fullscreen && !graphics.IsFullScreen)
                {
                    width = 1280;
                    height = 800;
                    TryPickingDefaultUIScale(800f);
                }
            }
            if (Platform.IsWindows)
            {
                form.MinimumSize = new Size(0, 0);
                if (!fullscreen && !flag3)
                {
                    SetDisplayModeAsBorderless(ref width, ref height, form);
                }
            }
            if (width > maxScreenW)
            {
                float num = (float)height / (float)width;
                width = maxScreenW;
                height = (int)(num * (float)width);
            }
            if (height > maxScreenH)
            {
                float num2 = (float)width / (float)height;
                height = maxScreenH;
                width = (int)(num2 * (float)height);
            }
            PlayerInput.RawMouseScale = new Vector2((float)width / (float)instance.Window.ClientBounds.Width, (float)height / (float)instance.Window.ClientBounds.Height);
            if (!graphics.IsFullScreen)
            {
                num3 = Math.Max(graphics.PreferredBackBufferWidth, graphics.GraphicsDevice.Viewport.Width);
                num4 = Math.Max(graphics.PreferredBackBufferHeight, graphics.GraphicsDevice.Viewport.Height);
                if (num3 != graphics.PreferredBackBufferWidth || num4 != graphics.PreferredBackBufferHeight)
                {
                    flag2 = true;
                }
            }
            else
            {
                num3 = graphics.PreferredBackBufferWidth;
                num4 = graphics.PreferredBackBufferHeight;
            }
        }
        else
        {
            PlayerInput.RawMouseScale = Vector2.One;
            if (Platform.IsWindows)
            {
                form.MinimumSize = new Size(minScreenW, minScreenH);
                if (flag)
                {
                    width = displayWidth[0];
                    height = displayHeight[0];
                }
            }
            width = Math.Min(width, maxScreenW);
            height = Math.Min(height, maxScreenH);
            num3 = graphics.GraphicsDevice.Viewport.Width;
            num4 = graphics.GraphicsDevice.Viewport.Height;
            flag2 = graphics.PreferredBackBufferWidth != graphics.GraphicsDevice.Viewport.Width || graphics.PreferredBackBufferHeight != graphics.GraphicsDevice.Viewport.Height;
        }
        if (Platform.IsWindows && !fullscreen && !flag2)
        {
            if (form.ClientSize.Width < graphics.PreferredBackBufferWidth)
            {
                width = form.ClientSize.Width;
                flag2 = true;
            }
            if (form.ClientSize.Height < graphics.PreferredBackBufferHeight)
            {
                height = form.ClientSize.Height;
                flag2 = true;
            }
        }
        width &= 0x7FFFFFFE;
        height &= 0x7FFFFFFE;
        width = Math.Max(width, minScreenW);
        height = Math.Max(height, minScreenH);
        if (graphics.IsFullScreen != fullscreen)
        {
            graphics.PreferredBackBufferWidth = width;
            graphics.PreferredBackBufferHeight = height;
            graphics.ApplyChanges();
            graphics.ToggleFullScreen();
        }
        if (width != num3 || height != num4 || flag2)
        {
            mapTime = 0;
            if (gamePaused)
            {
                renderNow = true;
            }
            screenWidth = width;
            screenHeight = height;
            graphics.PreferredBackBufferWidth = screenWidth;
            graphics.PreferredBackBufferHeight = screenHeight;
            graphics.ApplyChanges();
            PlayerInput.CacheOriginalScreenDimensions();
            FixUIScale();
            if (Main.OnResolutionChanged != null)
            {
                Main.OnResolutionChanged(new Vector2(screenWidth, screenHeight));
            }
            PendingResolutionWidth = screenWidth;
            PendingResolutionHeight = screenHeight;
            PlayerInput.CacheOriginalScreenDimensions();
            if (Platform.IsWindows && !fullscreen)
            {
                if (screenBorderless)
                {
                    ApplyBorderlessResolution(form);
                    form.FormBorderStyle = FormBorderStyle.None;
                }
                else
                {
                    form.FormBorderStyle = FormBorderStyle.Sizable;
                }
                form.SendToBack();
                form.BringToFront();
            }
            Lighting.Initialize();
            if (!drawToScreen && !_isResizingAndRemakingTargets)
            {
                _isResizingAndRemakingTargets = true;
                instance.InitTargets();
                _isResizingAndRemakingTargets = false;
            }
            UserInterface.ActiveInstance.Recalculate();
            instance._needsMenuUIRecalculation = true;
            Console.WriteLine(Language.GetTextValue("Misc.ResolutionChanged", width, height));
            chatMonitor.OnResolutionChange();
        }
        if (!graphics.SynchronizeWithVerticalRetrace)
        {
            graphics.SynchronizeWithVerticalRetrace = true;
            graphics.ApplyChanges();
        }
    }
 
    public static void FixUIScale()
    {
        UIScale = UIScaleWanted;
    }
 
    public void FullscreenStartup()
    {
        startFullscreen = false;
        int currentValue = graphics.PreferredBackBufferWidth;
        int currentValue2 = graphics.PreferredBackBufferHeight;
        Configuration.Get("DisplayWidth", ref currentValue);
        Configuration.Get("DisplayHeight", ref currentValue2);
        SetDisplayMode(currentValue, currentValue2, fullscreen: true);
    }
 
    public void UpdateDisplaySettings()
    {
        if (startFullscreen)
        {
            FullscreenStartup();
        }
        SetResolution(base.GraphicsDevice.Viewport.Width, base.GraphicsDevice.Viewport.Height);
    }
 
    public static void OpenPlayerSelect(OnPlayerSelected method)
    {
        if ((gameMenu && (menuMode == 10 || menuMode == 14)) || WorldGen.gen)
        {
            return;
        }
        if (!gameMenu)
        {
            WorldGen.SaveAndQuit(delegate
            {
                menuMode = 888;
                _blockFancyUIWhileLoading = true;
                LoadPlayers();
                MenuUI.SetState(_characterSelectMenu);
                _blockFancyUIWhileLoading = false;
                _pendingCharacterSelect = method;
            });
        }
        else
        {
            menuMode = 888;
            _blockFancyUIWhileLoading = true;
            LoadPlayers();
            MenuUI.SetState(_characterSelectMenu);
            _blockFancyUIWhileLoading = false;
            _pendingCharacterSelect = method;
        }
    }
 
    public static void SwitchNetMode(int mode)
    {
        if (mode >= 0 && mode <= 2)
        {
            _targetNetMode = mode;
            _hasPendingNetmodeChange = true;
        }
    }
 
    public static void WeGameRequireExitGame()
    {
        GameAskedToQuit = true;
    }
}